{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EheA5_j_cEwc"
      },
      "source": [
        "##### Copyright 2019 Google LLC.\n",
        "\n",
        "Licensed under the Apache License, Version 2.0 (the \"License\");"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "YCriMWd-pRTP"
      },
      "outputs": [],
      "source": [
        "#@title Licensed under the Apache License, Version 2.0 (the \"License\"); { display-mode: \"form\" }\n",
        "# you may not use this file except in compliance with the License.\n",
        "# You may obtain a copy of the License at\n",
        "#\n",
        "# https://www.apache.org/licenses/LICENSE-2.0\n",
        "#\n",
        "# Unless required by applicable law or agreed to in writing, software\n",
        "# distributed under the License is distributed on an \"AS IS\" BASIS,\n",
        "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
        "# See the License for the specific language governing permissions and\n",
        "# limitations under the License."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OvRwFTkqcp1e"
      },
      "source": [
        "# American Option Pricing in TFF under the Black-Scholes Model\n",
        "\n",
        "\u003ctable class=\"tfo-notebook-buttons\" align=\"left\"\u003e\n",
        "  \u003ctd\u003e\n",
        "    \u003ca target=\"_blank\" href=\"https://colab.research.google.com/github/google/tf-quant-finance/blob/master/tf_quant_finance/examples/jupyter_notebooks/American_Option_Black_Scholes.ipynb\"\u003e\u003cimg src=\"https://www.tensorflow.org/images/colab_logo_32px.png\" /\u003eRun in Google Colab\u003c/a\u003e\n",
        "  \u003c/td\u003e\n",
        "  \u003ctd\u003e\n",
        "    \u003ca target=\"_blank\" href=\"https://github.com/google/tf-quant-finance/blob/master/tf_quant_finance/examples/jupyter_notebooks/American_Option_Black_Scholes.ipynb\"\u003e\u003cimg src=\"https://www.tensorflow.org/images/GitHub-Mark-32px.png\" /\u003eView source on GitHub\u003c/a\u003e\n",
        "  \u003c/td\u003e\n",
        "\u003c/table\u003e"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "uG8UAZXjeUhf"
      },
      "outputs": [],
      "source": [
        "#@title Upgrade to TensorFlow 2.5+\n",
        "!pip install --upgrade tensorflow --user"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aijwbAA8u_IM",
        "outputId": "58ba5990-23e9-401c-d446-c56746d7892c"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Collecting tf-quant-finance\n",
            "  Downloading tf_quant_finance-0.0.1.dev27-py2.py3-none-any.whl (1.4 MB)\n",
            "\u001b[K     |████████████████████████████████| 1.4 MB 9.4 MB/s eta 0:00:01\n",
            "\u001b[?25hRequirement already satisfied: protobuf in /opt/conda/lib/python3.7/site-packages (from tf-quant-finance) (3.16.0)\n",
            "Requirement already satisfied: numpy\u003e=1.19.2 in /opt/conda/lib/python3.7/site-packages (from tf-quant-finance) (1.19.5)\n",
            "Requirement already satisfied: tensorflow-probability\u003e=0.11.0 in /opt/conda/lib/python3.7/site-packages (from tf-quant-finance) (0.13.0rc0)\n",
            "Requirement already satisfied: attrs\u003e=18.2.0 in /opt/conda/lib/python3.7/site-packages (from tf-quant-finance) (21.2.0)\n",
            "Requirement already satisfied: six\u003e=1.10.0 in /opt/conda/lib/python3.7/site-packages (from tensorflow-probability\u003e=0.11.0-\u003etf-quant-finance) (1.16.0)\n",
            "Requirement already satisfied: dm-tree in /opt/conda/lib/python3.7/site-packages (from tensorflow-probability\u003e=0.11.0-\u003etf-quant-finance) (0.1.6)\n",
            "Requirement already satisfied: gast\u003e=0.3.2 in /opt/conda/lib/python3.7/site-packages (from tensorflow-probability\u003e=0.11.0-\u003etf-quant-finance) (0.4.0)\n",
            "Requirement already satisfied: decorator in /opt/conda/lib/python3.7/site-packages (from tensorflow-probability\u003e=0.11.0-\u003etf-quant-finance) (5.0.9)\n",
            "Requirement already satisfied: cloudpickle\u003e=1.3 in /opt/conda/lib/python3.7/site-packages (from tensorflow-probability\u003e=0.11.0-\u003etf-quant-finance) (1.6.0)\n",
            "Installing collected packages: tf-quant-finance\n",
            "Successfully installed tf-quant-finance-0.0.1.dev27\n"
          ]
        }
      ],
      "source": [
        "#@title Install TF Quant Finance\n",
        "!pip install tf-quant-finance"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "roUegEh5eh04",
        "outputId": "db3ddb25-3824-4ea4-ac37-23224969d671"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Collecting QuantLib-Python\n",
            "  Downloading QuantLib_Python-1.18-py2.py3-none-any.whl (1.4 kB)\n",
            "Collecting QuantLib\n",
            "  Downloading QuantLib-1.23-cp37-cp37m-manylinux_2_12_x86_64.manylinux2010_x86_64.whl (20.1 MB)\n",
            "\u001b[K     |████████████████████████████████| 20.1 MB 7.2 MB/s eta 0:00:01\n",
            "\u001b[?25hInstalling collected packages: QuantLib, QuantLib-Python\n",
            "Successfully installed QuantLib-1.23 QuantLib-Python-1.18\n"
          ]
        }
      ],
      "source": [
        "#@title Install QuantLib\n",
        "!pip install QuantLib-Python"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ku46LPe6Jswv"
      },
      "source": [
        "### This notebook demonstrates the use of low level Tensorflow Quant Finance tools for American Option pricing under the Black-Scholes model with emphasis on the following aspects:\n",
        "\n",
        "  * **Batching**: Tensorflow is vectorized out of the box. Tensorflow Finance (TFF) written to leverage this wherever possible.\n",
        "    * Most methods accept a \"batch\" of inputs.\n",
        "  * **Hardware Accelerators**: Tensorflow supports GPUs without any code changes. Significant speedups with no code change.\n",
        "    * Write the model once and run it on CPU or GPU.\n",
        "    * Use XLA-compiler to improve performance. \n",
        "\n",
        "      **NB** PDE solvers rely on tridiagonal equation system solver. At the moment JIT compilation uses Thomas algorithm for all platforms (both CPUs and GPUs) so speed up from XLA compilation is only observed for CPU devices. \n",
        "\n",
        "The reported numbers below are obtained using standard Colab runtime on\n",
        "[`n1-highmem-2`](https://cloud.google.com/compute/docs/general-purpose-machines#n1_machines) VM with `Tesla V100 GPU`\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RNwEimy9MzVm",
        "outputId": "f98d6787-5ed2-475c-83b2-15e6b099c477"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Fri Jul 16 14:09:56 2021       \n",
            "+-----------------------------------------------------------------------------+\n",
            "| NVIDIA-SMI 460.73.01    Driver Version: 460.73.01    CUDA Version: 11.2     |\n",
            "|-------------------------------+----------------------+----------------------+\n",
            "| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |\n",
            "| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |\n",
            "|                               |                      |               MIG M. |\n",
            "|===============================+======================+======================|\n",
            "|   0  Tesla V100-SXM2...  Off  | 00000000:00:04.0 Off |                    0 |\n",
            "| N/A   35C    P0    38W / 300W |  15539MiB / 16160MiB |      0%      Default |\n",
            "|                               |                      |                  N/A |\n",
            "+-------------------------------+----------------------+----------------------+\n",
            "                                                                               \n",
            "+-----------------------------------------------------------------------------+\n",
            "| Processes:                                                                  |\n",
            "|  GPU   GI   CI        PID   Type   Process name                  GPU Memory |\n",
            "|        ID   ID                                                   Usage      |\n",
            "|=============================================================================|\n",
            "|    0   N/A  N/A     26484      C   /opt/conda/bin/python           15537MiB |\n",
            "+-----------------------------------------------------------------------------+\n"
          ]
        }
      ],
      "source": [
        "# Get GPU info\n",
        "!nvidia-smi"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "m8zQZExTNEAC"
      },
      "outputs": [],
      "source": [
        "# Get CPU info\n",
        "!cat /proc/cpuinfo"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "2nA2FSdTgcEM",
        "outputId": "5fc16840-0d8f-4ef0-c597-27df47e28e08"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "2021-07-16 13:33:18.352019: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcudart.so.11.0\n"
          ]
        }
      ],
      "source": [
        "#@title **Imports** { display-mode: \"form\" }\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "import time\n",
        "\n",
        "import pandas as pd\n",
        "import seaborn as sns\n",
        "\n",
        "import tensorflow as tf\n",
        "\n",
        "# Import for Tensorflow Quant Finance\n",
        "import tf_quant_finance as tff \n",
        "\n",
        "# Shortcut alias\n",
        "pde = tff.math.pde\n",
        "\n",
        "from IPython.core.pylabtools import figsize\n",
        "figsize(21, 14)  # better graph size for Colab  \n",
        "\n",
        "import QuantLib as ql\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KsVBo68Fabgt"
      },
      "source": [
        " ### Setup American Option pricer\n",
        "   American option price $V(x, t)$ of an option with spot price $x$ at time $t$\n",
        "   under Black-Scholes model satisfies the following PDE\n",
        "   $$V_{t} + \\frac{\\sigma^2}{2}  x^2  V_{xx} + r  x  V_{x}\n",
        " - r  V(t, x) = 0.$$\n",
        "  Tensorflow Quant Finance library provides tools for solving Parabolic PDE's\n",
        "  of the form  \n",
        "  $$V_{t} + \\frac{a(t, x)}{2}  V_{xx} + b(t, x) V_{x} - c(t, x)  V = 0$$\n",
        "\n",
        "  Henceforth,\n",
        "  $a(t, x)$, $b(t, x)$, and $c(t, x)$ are referred to as quadratic, linear and\n",
        "  shift coefficients, respectively. We describe in details how to write a\n",
        "  custom pricer that is both batchable (i.e., multiple equations can be solved\n",
        "  simultaneously) and compatible with an NVIDIA GPU. \n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "13_gS0ZIBw2x"
      },
      "outputs": [],
      "source": [
        "#@title **American Option pricer**\n",
        "\n",
        "# tf.function decorator makes the function faster in graph mode.\n",
        "@tf.function\n",
        "def american_option(number_grid_points,\n",
        "                    time_delta,\n",
        "                    strike,\n",
        "                    volatility,\n",
        "                    risk_free_rate,\n",
        "                    expiry,\n",
        "                    dtype=tf.float64):\n",
        "  \"\"\" Computes American Call options prices.\n",
        "\n",
        "  Args:\n",
        "    number_grid_points: A Python int. Number of grid points for the finite\n",
        "      difference scheme.\n",
        "    time_delta: A Python float. Grid time discretization parameter.\n",
        "    strike: A real `Tensor` of shape `(number_of_options, 1)`.\n",
        "      Represents the strikes of the underlying American options. \n",
        "    volatility: A real `Tensor` of shape `(number_of_options, 1)`.\n",
        "      Represents the volatilities of the underlying American options. \n",
        "    risk_free_rate: A real `Tensor` of shape `(number_of_options, 1)`.\n",
        "      Represents the risk-free interest rates associated with the underlying\n",
        "      American options.\n",
        "    expiry: A Python float. Expiry date of the options. If the options\n",
        "      have different expiries, volatility term has to adjusted to\n",
        "      make expiries the same.\n",
        "    dtype: Optional `tf.dtype` used to assert dtype of the input `Tensor`s.\n",
        "\n",
        "  Returns:\n",
        "    A tuple of the estimated option prices of shape\n",
        "    `(number_of_options, number_grid_points)` and the corresponding `Tensor` \n",
        "    of grid locations of shape `(number_grid_points,)`.\n",
        "  \"\"\"\n",
        "  # Define the coordinate grid\n",
        "  s_min = 0.01\n",
        "  s_max = 300.\n",
        "  grid = pde.grids.uniform_grid(minimums=[s_min],\n",
        "                                maximums=[s_max],\n",
        "                                sizes=[number_grid_points],\n",
        "                                dtype=dtype)\n",
        "\n",
        "  # Define the values grid for the final condition\n",
        "  s = grid[0]\n",
        "  final_values_grid = tf.nn.relu(s - strike)\n",
        "\n",
        "  # Define the PDE coefficient functions\n",
        "  def second_order_coeff_fn(t, grid):\n",
        "    del t\n",
        "    s = grid[0]\n",
        "    return [[volatility ** 2 * s ** 2 / 2]]\n",
        "\n",
        "  def first_order_coeff_fn(t, grid):\n",
        "    del t\n",
        "    s = grid[0]\n",
        "    return [risk_free_rate * s]\n",
        "\n",
        "  def zeroth_order_coeff_fn(t, grid):\n",
        "    del t, grid\n",
        "    return -risk_free_rate\n",
        "\n",
        "  # Define the boundary conditions\n",
        "  @pde.boundary_conditions.dirichlet\n",
        "  def lower_boundary_fn(t, grid):\n",
        "    del t, grid\n",
        "    return tf.constant(0.0, dtype=dtype)\n",
        "\n",
        "  @pde.boundary_conditions.dirichlet\n",
        "  def upper_boundary_fn(t, grid):\n",
        "    del grid\n",
        "    return tf.squeeze(s_max - strike * tf.exp(-risk_free_rate * (expiry - t)))\n",
        "\n",
        "  # In order to price American option one needs to set option values to \n",
        "  # V(x) := max(V(x), max(x - strike, 0)) after each iteration\n",
        "  def values_transform_fn(t, grid, values):\n",
        "    del t\n",
        "    s = grid[0]\n",
        "    values_floor = tf.nn.relu(s - strike)\n",
        "    return grid, tf.maximum(values, values_floor)\n",
        "\n",
        "  # Solve\n",
        "  estimate_values, estimate_grid, _, _ = \\\n",
        "    pde.fd_solvers.solve_backward(\n",
        "      start_time=expiry,\n",
        "      end_time=0,\n",
        "      values_transform_fn=values_transform_fn,\n",
        "      coord_grid=grid,\n",
        "      values_grid=final_values_grid,\n",
        "      time_step=time_delta,\n",
        "      boundary_conditions=[(lower_boundary_fn, upper_boundary_fn)],\n",
        "      second_order_coeff_fn=second_order_coeff_fn,\n",
        "      first_order_coeff_fn=first_order_coeff_fn,\n",
        "      zeroth_order_coeff_fn=zeroth_order_coeff_fn,\n",
        "      dtype=dtype\n",
        "    )\n",
        "  return estimate_values, estimate_grid[0]\n",
        "\n",
        "\n",
        "def option_param(number_of_options, dtype, seed=42):\n",
        "  \"\"\" Function to generate volatilities, rates, strikes \"\"\"\n",
        "  np.random.seed(seed)\n",
        "  if number_of_options \u003e 1:\n",
        "    volatility = tf.random.uniform(shape=(number_of_options, 1),\n",
        "                                   dtype=dtype) * 0.1 + 0.3\n",
        "    # Random risk free rate between 0 and 0.2.\n",
        "    risk_free_rate = tf.constant(\n",
        "      np.random.rand(number_of_options, 1) * 0.05, dtype)\n",
        "    # Random strike between 20 and 120.\n",
        "    strike = tf.constant(\n",
        "      np.random.rand(number_of_options, 1) * 100 + 50, dtype)\n",
        "  else:\n",
        "    volatility = tf.constant([0.3], dtype)\n",
        "    risk_free_rate = tf.constant([0.05], dtype)\n",
        "    strike = tf.constant([50], dtype)\n",
        "  return volatility, risk_free_rate, strike"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OnijmIHSD5_a"
      },
      "source": [
        "### Batching\n",
        "\n",
        "* Batching is a powerful feature of design of Tensorflow.\n",
        "* TFF leverages this strongly.\n",
        "* Most methods can accept a \"batch\" of inputs.\n",
        "* Example below (Batch of American Call Options with varying strikes, vols and rates).\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "qAPYRpLIEgPH"
      },
      "outputs": [],
      "source": [
        "#@title Price multiple American Call options at a time\n",
        "\n",
        "number_of_options = 10 #@param\n",
        "\n",
        "time_delta = 0.005\n",
        "\n",
        "expiry = 1.0  \n",
        "\n",
        "number_grid_points = 1024 \n",
        "\n",
        "dtype = tf.float64 \n",
        "\n",
        "spot = 110  + tf.random.uniform(shape=[number_of_options, 1], dtype=dtype)\n",
        "\n",
        "# Generate volatilities, rates, strikes\n",
        "volatility, risk_free_rate, strike = option_param(number_of_options, dtype)\n",
        "\n",
        "# Build a graph to compute prices of the American Options.\n",
        "estimate, grid_locations = american_option(\n",
        "    time_delta=time_delta,\n",
        "    expiry=expiry,\n",
        "    number_grid_points=number_grid_points,\n",
        "    volatility=volatility,\n",
        "    risk_free_rate=risk_free_rate,\n",
        "    strike=strike,\n",
        "    dtype=dtype)\n",
        "\n",
        "# Convert to numpy for plotting\n",
        "estimate = estimate.numpy()\n",
        "grid_locations = grid_locations.numpy()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 535
        },
        "id": "I7eAh-_Z3jdK",
        "outputId": "d1526452-0d1b-4ae1-9914-b7410d8027db"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "\u003cFigure size 720x576 with 1 Axes\u003e"
            ]
          },
          "metadata": {
            "needs_background": "light",
            "tags": []
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "#@title Price/spot plot for the American Call options\n",
        "# Prepare data for plotting \n",
        "options = [x + 1 for x in range(number_of_options) for _ in range(1024)]\n",
        "plot_data = pd.DataFrame({\n",
        "    'Spot': list(np.ndarray.flatten(grid_locations)) * number_of_options, \n",
        "    'Price': estimate.flatten(),\n",
        "    'Option': options})\n",
        "\n",
        "\n",
        "# Plot\n",
        "plt.figure(figsize=(10, 8))\n",
        "sns.set(style=\"darkgrid\")\n",
        "sns.set_context(\"paper\", font_scale=1.5, rc={\"lines.linewidth\": 2.5})\n",
        "plot = sns.lineplot(x=\"Spot\", y=\"Price\", hue=\"Option\",\n",
        "                    data=plot_data,\n",
        "                    palette=sns.color_palette()[:number_of_options],\n",
        "                    legend=False)\n",
        "plot.axes.set_title(f\"Price/Spot for {number_of_options} American Call Options\",\n",
        "                    fontsize=25)\n",
        "xlabel = plot.axes.get_xlabel()\n",
        "ylabel = plot.axes.get_ylabel()\n",
        "plot.axes.set_xlabel(xlabel, fontsize=20)\n",
        "plot.axes.set_ylabel(ylabel, fontsize=20)\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "B4Y5lQV3S9l8"
      },
      "source": [
        "### Speedup from batching and XLA-compilation\n",
        "\n",
        "* Note that GPUs are particularly good for vectorized calculations. \n",
        "* XLA compilation (in this case Just-in-time compilation) improves CPU performance and demonstrates performance advantage over QuantLib."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YCWMBrv-S87k",
        "outputId": "c61ae5e1-0df2-47f9-c2ba-b30b15a25812"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "------------------------\n",
            "Tensorflow GPU\n",
            "wall time:  3.161587953567505\n",
            "options per second:  3162.967517230099\n",
            "------------------------\n"
          ]
        }
      ],
      "source": [
        "#@title Tensorflow Finance pricing on GPU\n",
        "\n",
        "number_of_options = 10000  #@param\n",
        "\n",
        "time_delta = 0.005\n",
        "\n",
        "expiry = 1.0 \n",
        "\n",
        "number_grid_points = 1024\n",
        "\n",
        "dtype = tf.float64\n",
        "\n",
        "# Generate volatilities, rates, strikes\n",
        "volatility, risk_free_rate, strike = option_param(number_of_options, dtype)\n",
        "\n",
        "device = \"/gpu:0\"\n",
        "with tf.device(device):\n",
        "  \n",
        "  # Warmup (graph construction + graph optimization)\n",
        "  estimate, _ = american_option(\n",
        "      time_delta=time_delta,\n",
        "      expiry=expiry,\n",
        "      number_grid_points=number_grid_points, \n",
        "      volatility=volatility,\n",
        "      risk_free_rate=risk_free_rate,\n",
        "      strike=strike,\n",
        "      dtype=dtype)\n",
        "\n",
        "  # Timed run\n",
        "  t = time.time()\n",
        "  estimate, _ = american_option(\n",
        "      time_delta=time_delta,\n",
        "      expiry=expiry,\n",
        "      number_grid_points=number_grid_points, \n",
        "      volatility=volatility,\n",
        "      risk_free_rate=risk_free_rate,\n",
        "      strike=strike,\n",
        "      dtype=dtype)\n",
        "  time_gpu = time.time() - t\n",
        "    \n",
        "gpu_options_per_second = number_of_options / time_gpu\n",
        "print('------------------------')\n",
        "print('Tensorflow GPU')\n",
        "print('wall time: ', time_gpu)\n",
        "print('options per second: ', gpu_options_per_second)\n",
        "print('------------------------')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Oav8Lit7Ox4-",
        "outputId": "7f24e0e9-c888-4386-ed20-1b708bf36bfe"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Tensorflow CPU\n",
            "wall time:  0.7148475646972656\n",
            "options per second:  69.94498193635835\n",
            "------------------------\n"
          ]
        }
      ],
      "source": [
        "#@title Tensorflow Finance pricing on CPU\n",
        "\n",
        "number_of_options = 50  #@param\n",
        "\n",
        "time_delta = 0.005\n",
        "\n",
        "expiry = 1.0 \n",
        "\n",
        "number_grid_points = 1024\n",
        "\n",
        "dtype = tf.float64\n",
        "\n",
        "# Generate volatilities, rates, strikes\n",
        "volatility, risk_free_rate, strike = option_param(number_of_options, dtype)\n",
        "\n",
        "device = \"/cpu:0\"\n",
        "with tf.device(device):\n",
        "  \n",
        "  # Warmup (graph construction + graph optimization + jit_compilation)\n",
        "  estimate, _ = american_option(\n",
        "      time_delta=time_delta,\n",
        "      expiry=expiry,\n",
        "      number_grid_points=number_grid_points, \n",
        "      volatility=volatility,\n",
        "      risk_free_rate=risk_free_rate,\n",
        "      strike=strike,\n",
        "      dtype=dtype)\n",
        "\n",
        "  # Timed run\n",
        "  t = time.time()\n",
        "  estimate, _ = american_option(\n",
        "      time_delta=time_delta,\n",
        "      expiry=expiry,\n",
        "      number_grid_points=number_grid_points, \n",
        "      volatility=volatility,\n",
        "      risk_free_rate=risk_free_rate,\n",
        "      strike=strike,\n",
        "      dtype=dtype)\n",
        "  time_cpu = time.time() - t\n",
        "\n",
        "cpu_options_per_second = number_of_options / time_cpu\n",
        "print('Tensorflow CPU')\n",
        "print('wall time: ', time_cpu)\n",
        "print('options per second: ', cpu_options_per_second)\n",
        "print('------------------------')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5arAmiJEu_Ip",
        "outputId": "ee096b11-0193-49a4-92ea-33d864c4accb"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "WARNING:tensorflow:5 out of the last 8 calls to \u003ctensorflow.python.eager.def_function.Function object at 0x7f679bb19ad0\u003e triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has reduce_retracing=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
            "Tensorflow CPU XLA\n",
            "wall time:  0.2038886547088623\n",
            "options per second:  245.2318892946557\n",
            "------------------------\n"
          ]
        }
      ],
      "source": [
        "#@title Tensorflow Finance pricing on CPU (with XLA-compiled compuation)\n",
        "\n",
        "number_of_options = 50  #@param\n",
        "\n",
        "time_delta = 0.005\n",
        "\n",
        "expiry = 1.0 \n",
        "\n",
        "number_grid_points = 1024\n",
        "\n",
        "dtype = tf.float64\n",
        "\n",
        "# Generate volatilities, rates, strikes\n",
        "volatility, risk_free_rate, strike = option_param(number_of_options, dtype)\n",
        "\n",
        "american_option_xla = tf.function(american_option, \n",
        "                                  jit_compile=True)\n",
        "device = \"/cpu:0\"\n",
        "with tf.device(device):\n",
        "  \n",
        "  # Warmup (graph construction + graph optimization)\n",
        "  estimate, _ = american_option_xla(\n",
        "      time_delta=time_delta,\n",
        "      expiry=expiry,\n",
        "      number_grid_points=number_grid_points, \n",
        "      volatility=volatility,\n",
        "      risk_free_rate=risk_free_rate,\n",
        "      strike=strike,\n",
        "      dtype=dtype)\n",
        "\n",
        "  # Timed run\n",
        "  t = time.time()\n",
        "  estimate, _ = american_option_xla(\n",
        "      time_delta=time_delta,\n",
        "      expiry=expiry,\n",
        "      number_grid_points=number_grid_points, \n",
        "      volatility=volatility,\n",
        "      risk_free_rate=risk_free_rate,\n",
        "      strike=strike,\n",
        "      dtype=dtype)\n",
        "  time_cpu = time.time() - t\n",
        "\n",
        "cpu_jit_options_per_second = number_of_options / time_cpu\n",
        "print('Tensorflow CPU XLA')\n",
        "print('wall time: ', time_cpu)\n",
        "print('options per second: ', cpu_jit_options_per_second)\n",
        "print('------------------------')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YxjImh_nJzqw",
        "outputId": "8747007a-66ef-4cee-bcba-4ee630878d3d"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "------------------------\n",
            "QuantLib\n",
            "wall time:  0.8111381530761719\n",
            "options per second:  61.64178051590754\n",
            "------------------------\n"
          ]
        }
      ],
      "source": [
        "#@title Quantlib  pricing\n",
        "\n",
        "# Will run only if QuantLib is installed\n",
        "\n",
        "number_of_options = 50  #@param\n",
        "\n",
        "dtype = tf.float64\n",
        "\n",
        "volatilities, risk_free_rates, strikes = option_param(number_of_options, dtype)\n",
        "\n",
        "(\n",
        "    volatilities, risk_free_rates, strikes\n",
        " ) = (volatilities.numpy(), \n",
        "      risk_free_rates.numpy(),\n",
        "      strikes.numpy()) \n",
        "\n",
        "time_delta = 0.005\n",
        "\n",
        "expiry = 1.0 \n",
        "\n",
        "number_grid_points = 1024\n",
        "\n",
        "spot_quote = ql.SimpleQuote(0.0)\n",
        "strike_quote = ql.SimpleQuote(0.0)\n",
        "rate_quote = ql.SimpleQuote(0.0)\n",
        "vol_quote = ql.SimpleQuote(0.0)\n",
        "\n",
        "# Initializers for American option pricer inputs\n",
        "spot_handle = ql.QuoteHandle(spot_quote)\n",
        "strike_handle = ql.QuoteHandle(strike_quote)\n",
        "rate_handle = ql.QuoteHandle(rate_quote)\n",
        "vol_handle = ql.QuoteHandle(vol_quote)\n",
        "\n",
        "\n",
        "calculation_date = ql.Date(1, 1, 2010)\n",
        "maturity_date = ql.Date(1, 1, 2011)\n",
        "day_count = ql.Thirty360(ql.Thirty360.BondBasis)\n",
        "calendar = ql.NullCalendar()\n",
        "\n",
        "option_type = ql.Option.Call\n",
        "\n",
        "# Create American option data\n",
        "ql.Settings.instance().evaluationDate = calculation_date\n",
        "\n",
        "am_exercise = ql.AmericanExercise(calculation_date, maturity_date)\n",
        "\n",
        "flat_ts = ql.YieldTermStructureHandle(\n",
        "    ql.FlatForward(calculation_date, rate_handle, day_count)\n",
        ")\n",
        "\n",
        "flat_vol_ts = ql.BlackVolTermStructureHandle(\n",
        "    ql.BlackConstantVol(calculation_date, calendar, vol_handle, day_count)\n",
        ")\n",
        "\n",
        "\n",
        "bsm_process = ql.BlackScholesProcess(spot_handle,\n",
        "                                      flat_ts,\n",
        "                                      flat_vol_ts)\n",
        "# Compute the same price number_of_options times for fair time comparison\n",
        "t = time.time()\n",
        "for vol, rate, strike in zip(volatilities, risk_free_rates, strikes): \n",
        "  strike_quote.setValue(strike[0])\n",
        "  spot_quote.setValue(strike[0])\n",
        "  rate_quote.setValue(rate[0])\n",
        "  vol_quote.setValue(vol[0])\n",
        "  fd_american_engine = ql.FdBlackScholesVanillaEngine(\n",
        "      bsm_process,\n",
        "      int(expiry / time_delta),\n",
        "      number_grid_points)\n",
        "  payoff = ql.PlainVanillaPayoff(option_type, strike[0])\n",
        "  # Create American option object\n",
        "  american_option_ql = ql.VanillaOption(payoff, am_exercise)\n",
        "  american_option_ql.setPricingEngine(fd_american_engine)\n",
        "  # Price calculation\n",
        "  price = american_option_ql.NPV()\n",
        "\n",
        "time_ql = time.time() - t\n",
        "\n",
        "ql_options_per_second = number_of_options / time_ql\n",
        "print('------------------------')\n",
        "print('QuantLib')\n",
        "print('wall time: ', time_ql)\n",
        "print('options per second: ', ql_options_per_second)\n",
        "print('------------------------')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 429
        },
        "id": "wUZv1UPdJ1DT",
        "outputId": "b0482c3c-a1f6-4954-c623-42e04bc3a74a"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "\u003cFigure size 864x432 with 1 Axes\u003e"
            ]
          },
          "metadata": {
            "tags": []
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "#@title Tensorflow Finance vs QuantLib\n",
        "# Throughput\n",
        "times_pd = pd.DataFrame([('QuantLib', ql_options_per_second), \n",
        "                         ('CPU', cpu_options_per_second),\n",
        "                         ('CPU XLA-compiled', cpu_jit_options_per_second), \n",
        "                         ('GPU', gpu_options_per_second)],\n",
        "                         columns=['Device', 'Options/sec'])\n",
        "sns.set(style=\"darkgrid\", palette=\"Paired\")\n",
        "sns.set_context(\"notebook\", font_scale=1.25, rc={\"lines.linewidth\": 2.5})\n",
        "plt.figure(figsize=(12, 6))\n",
        "pt = sns.barplot(y=\"Device\", x=\"Options/sec\", data=times_pd)\n",
        "pt.axes.set_title(\"Device Option Pricing Speed\", fontsize=25)\n",
        "xlabel = pt.axes.get_xlabel()\n",
        "ylabel = pt.axes.get_ylabel()\n",
        "pt.axes.set_xlabel(xlabel, fontsize=20)\n",
        "pt.axes.set_ylabel(ylabel, fontsize=20)\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 480
        },
        "id": "lr3FSrVfSpk6",
        "outputId": "42d1c5e6-8bce-40ea-d4f0-69b97b826fc6"
      },
      "outputs": [
        {
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAuQAAAGWCAYAAAAwppYyAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAACOzElEQVR4nOzdd1xV9f8H8Ne9l72nCLIUBScgigi498KZZcO0+mblSBum6bevaWrmr2zZ0MpcaWaWCWruzXJCiluZIrL3uOP8/jAOXLnoRYHLeD0fjx7B+5x7zvveD+Drnvs550gEQRBAREREREQ6IdV1A0REREREzRkDORERERGRDjGQExERERHpEAM5EREREZEOMZATEREREekQAzkRERERkQ4xkBM1U5MnT4aXl5eu26BGLjk5GV5eXpg/f76uW9FKVFQUvLy88PXXX+u6lUZB16/XH3/8AS8vL/zxxx862T9RfdHTdQNEzc0///yDLVu2IDo6Gunp6dDT00OrVq3Qq1cvTJ06FQ4ODrWyn/nz5+PPP//EoUOH4OzsXCvbrC/Z2dnYsmULTpw4gdu3b6OgoABmZmbw8PBAnz598NRTT8HOzk7Xbdarr7/+GqtXr8bGjRsREBBQJ/uYPHkyoqOjtV5/3LhxmDlzZp300hQlJydj4MCBVeqGhoZo2bIlgoODMW3aNDg6OtbKfsaNG4cVK1Y80bZqm1KpxI4dO7Br1y5cu3YNhYWFsLCwgJ2dHby9vTFgwACNrxFRU8dATlRPBEHAp59+ih9//BF6enoICgrCsGHDIJfLcf78eaxbtw5bt27FihUrMGzYsDrv55NPPkFxcXGd76emjhw5grlz5yI/Px9ubm4YPHgwbG1tkZ+fj5iYGHzxxRdYs2YN9u/fD3t7e12326SMGzcOPXr0UKsdPHgQV65cwcCBA9GhQwe1ZR06dICDgwP27NkDc3Pz+my1UTM3N8eUKVPE73NychAdHY0tW7Zg3759+PPPP2vtjXlDolQq8dprr+HEiROwsLBA37590bJlS+Tm5iIxMRFhYWG4deuWWiAfPHgwfHx80KJFCx12TlT3GMiJ6sk333yDH3/8Ea1atcKaNWvQrl07teX79u3D3Llz8fbbb8PKygo9e/as036cnJzqdPuPIzo6GrNmzYJUKsXHH3+McePGQSKRqK1z9epVLFu2DKWlpTrqsukaP358lVpKSgquXLmCQYMGaVwOAB4eHnXdWpNiYWGBWbNmVam//vrrOHLkCH777TeNyxu7sLAwnDhxAu3bt8fmzZurvIkrLi5GTEyMWs3c3Jxv9qhZ4BxyonqQnJyM7777Dvr6+vjuu++qhHEAGDp0KN5//30olUp8+OGHUKlU4rLK8yiPHj2KSZMmwdfXF/7+/njzzTcRHx+vti0vLy/8+eefAICBAwfCy8sLXl5eGDBggLhOdXPIVSoVtm7digkTJqBr167w9fXFhAkTsGXLFrWeKu9r8uTJyMrKwgcffIBevXqhc+fOGDlyJHbs2KH1a6RSqbBo0SLI5XIsXLgQ48ePrxLGy/e3fv36KkcQL168iFmzZiEwMBCdO3dG//798eGHH+LevXtVtjF//nx4eXkhKSkJmzdvxogRI9ClSxcMGDAA33//PQRBAADs3bsXTz31FHx9fREYGIglS5ZofCNQ/hqkpaVh7ty5CAwMhLe3N8aPH4/Q0NAq6z9qXmz59soNGDAAq1evBgC8+OKL4ng+OH7FxcVYs2YNxowZA19fX3Tt2hXPPPMMwsLCNO6nNlQ3h7y2X2MAuHnzJubPn4++ffuic+fOCAoKwjvvvINbt249Vu/nz5/H1KlT0a1bN3Tt2hWvvPIK/vnnH7V1Pv30U3h5eWHnzp0at3Hx4kV4eXnh9ddff6weKgsODgYAZGVlqdXT0tKwevVqTJo0CcHBwejcuTN69eqFd955Bzdv3lRb9+uvvxaPMP/5559qPysP/rydPHkSr7/+uvg707dvX7zxxhsIDw/X2N/ly5cxbdo0dO/eHT4+PnjhhRdw7tw5rZ/f+fPnAdz/JEZTyDY2Nq5yIELT70r5z1Z1/1X+O1cuLCwMkydPhr+/P7p06YLhw4fj22+/RVlZmdb9E9UlHiEnqgd//PEHFAoFhg8f/tATKSdOnIhvv/0Wt2/fRnR0dJV/nPbv348TJ05g0KBB6NGjBy5fvox9+/YhKioKW7duRZs2bQAAM2fOFKcavPjii7CwsAAArY40zZ07F2FhYXB0dMRTTz0FiUSCgwcPYvHixTh79iw+++yzKo/Jy8vDs88+CwMDAwwdOhSlpaXYt28fFixYAKlUinHjxj1yv9HR0bh16xYcHBzw1FNPPXRdqVQKqbTieMKRI0fEI4pDhw6Fk5MTLl26hK1bt+LQoUPYunWrxnn0K1euRHR0NPr374/g4GAcPnwYn3/+OeRyOSwtLfHZZ59h0KBB6N69O06dOoVffvkFSqUSixcvrrKt3NxcPPvsszA3N8f48eORn5+PvXv34t1330VaWhr+85//PPI1qM6LL76IQ4cOITo6GuPGjUOrVq2qrJOXl4cpU6YgLi4OnTp1woQJE6BSqXDy5Em88847uH79Ot56663H7uFx1dZrfPz4ccyaNQsKhQL9+/eHq6sr0tLSsH//fhw9ehQbN25Ep06dtO4rJiYGa9asQVBQEJ5//nkkJCTgwIEDOH36NNatW4fu3bsDACZNmoSffvoJv/76K8aOHVtlO9u2bQMAPPPMM4//Iv0rIiICANC5c2e1+pkzZ/DDDz8gICAAQ4YMgYmJCRISErBv3z4cPnwYW7duRfv27QEAPXr0wIsvvoiNGzeiffv2GDRokLidylOOvvrqK3zzzTcwMTHBoEGD4OjoiHv37uH8+fPYtWsXgoKC1Hq4ePEifvzxR/j6+mLixIm4c+cO9u/fj6lTp2Lnzp3i356HsbKyAoAqBxBqatCgQRp/B65du4b9+/fDyMhIrb5gwQLs2LEDLVu2xODBg2FhYYELFy7gyy+/REREBH7++Wfo6TEOkY4JRFTnXnzxRcHT01PYtm3bI9d9++23BU9PT+Gbb74Razt27BA8PT0FT09P4fDhw2rrr1+/XvD09BRefPFFtfq8efMET09PISkpSeN+XnjhBcHT01OtFhoaKnh6egpjx44VCgoKxHphYaEwbtw4wdPTU9i1a5faY8r7WrBggaBQKMT69evXhQ4dOgjDhw9/5HMWBEFYvXq14OnpKbzzzjtarV+uoKBA6NGjh9C+fXvh9OnTasvWrFkjeHp6Ci+99JJavfy16d+/v3D37l2xnpubK/To0UPw8fERAgIChBs3bojLSktLheHDhwudOnUSMjIy1LZX/hq8+eabglKpFOuJiYmCv7+/0KlTJyExMVGsl4/njh07ND4nT09P4YUXXlCrffXVV4Knp6cQGRmp8THlz2nt2rVq9ZKSEuHll18WvLy8hLi4OI2PfZjy7VbXa1JSkuDp6SnMmzdP4+Nq4zXOyckRunfvLvTo0UO4fv262n6uXbsm+Pr6CmPHjtXq+URGRorjtWnTJrVlBw4cEDw9PYXBgwerjeO0adMET09P4cqVK2rrFxQUCL6+vkLfvn3VfvarU/5adevWTfjqq6/E/z766CNhzJgxQocOHYT58+cLcrlc7XEZGRlCfn5+le1dvnxZ8PX1FV555RWN+3lwTMqdOHFC8PT0FAYMGKA2NuVSU1PFryu/Xg/+DGzdulXw9PQUFi1a9MjnLgiCcOnSJaFTp06Cl5eX8O677wr79u0TkpOTH/qYR/2uVO65d+/eQpcuXYTz589XefyMGTOE4uJitceU/06tX79eq/6J6hKnrBDVg/T0dABAy5YtH7lu+RUWNE216NmzJ/r3769We+GFF+Dq6orIyEikpKQ8UZ/lU0zeeecdmJqainUTExPMnTsXALB9+/YqjzM2Nsb7778PmUwm1tq2bQs/Pz/cvHkTBQUFj9x3TV6jyg4dOoScnByMGDFCPKpZ7uWXX0arVq1w6tQp3Llzp8pj33jjDbWpLxYWFhgwYACKi4vx7LPPqs2NNjAwwIgRIyCXy6tMEwAAmUyGd999V+3IvYuLCyZPngy5XI6//vqrRs+rJrKzs7Fr1y507twZr776qtoyQ0NDzJ07F4IgaJw+U9dq4zXeuXMn8vLy8Oabb6Jt27Zq22/Xrh0mTpyIuLg43LhxQ+u+3Nzc8Nxzz6nVyj95SkhIwJkzZ8T6s88+CwD47bff1NYPDQ1FUVERnnrqKbWf/UfJz8/H6tWrxf82bdqEy5cvi1MpHjxaa2trCzMzsyrbad++PQICAhAVFQW5XK71/jdv3gzg/tQPTSePavod9PPzq3IOwYQJE6Cnp4fY2Fit9tuxY0esXLkSdnZ22LVrF2bNmoUBAwYgICAAM2bMwOHDh7V+DpUVFBTgtddew71797By5Ur4+vqKyzZu3Ag9PT0sX768ypHz6dOnw8rKSie/F0QP4mc0RPVA+He+rKY50TVZ19/fv0pNJpOhW7duSExMxOXLlzV+lKutuLg4SKXSKlfaKN+3TCbD5cuXqyxzc3PTGBjK/2HPz8/XuLyymrxGD/YMQONJsHp6evD390dKSgri4uKqnMjapUuXKo8pv5qDpukP5eHl7t27VZY5OjrCxcWlSr38tSzvsy78888/UCqVkEgkGq8XrVAoAOCx51o/idp4jS9cuAAAuHLlisbnVz4F4ubNm1UCe3W6deum9uapXI8ePRAdHY24uDhx7Pr06QNnZ2f89ddfePfdd2FsbAzgfkCXyWSYOHGiVvss16pVK7XwmZ+fj7i4OCxfvhzTpk3D4sWLq0yBOXr0KH799VdcvHgR2dnZ4piWy87O1vpKJBcuXIBEIkHv3r217vnBaTQAoK+vD1tbW+Tl5Wm9nREjRmDw4MGIiorC2bNncfnyZZw9exYHDx7EwYMHMXbsWKxYsULrvwNKpRJz5szBlStXMHfuXLUrVBUXF+PKlSuwtrbGhg0bND7ewMBA4xtsovrGQE5UD+zt7XHr1i2kpqY+ct3yIKLpkn7VXXu7vJ6fn/8EXd5/vKWlJQwMDKos09PTg7W1NTIzM6ssK5+jrukxwP1/NB+lPExoCrsPU/6cq7sEYnld02uj6U1Cec+a5tuXHwV9MAwBdT82D5OTkwPgfjB/8KTEygoLC+ush+rUxmtc/vwePEL9oKKiIq37etR4Vf5URyqV4plnnsFnn32GPXv2YMKECbh48SIuXbqEQYMGPfElCs3NzREQEICvvvoKQ4YMwaeffooxY8aIR3Q3btyIZcuWwdLSEkFBQXB0dISxsbF4fseVK1dqdHJi+e/5g0eMH+Zhv+OaTvZ+GH19ffTq1Qu9evUCcP/vw759+7Bw4ULs3LkTgwcPVpv7/jCLFy/GiRMn8Mwzz1Q5TyMvLw+CICArK0s8KZqooWIgJ6oH3bp1Q1RUFMLDw/H0009Xu55SqRRvzOLn51dleUZGhsbHldef9PJg5ubmyM3NhVwuh76+vtoyhUKB7OzsRx7pflzdunUDcP/kTqVSqfUUgPLnXD7l5UHl9bq+dFpNxqb8yKymNyo1OdpYrnzbU6dOxfvvv1/jxzd05c/vr7/+Ek9efFKPGq8Hf86feuopfP3119i2bRsmTJhQqydzlnNzc4OVlRVycnIQHx+P9u3bQ6FQ4Ouvv4a9vT3++OOPKkfByz89qAlzc3Pk5OSgpKSkRqG8rshkMowYMQLXrl3Dd999h8jISK0C+Q8//IBt27ahd+/eWLRoUZXl5WPYsWNH8apTRA0V55AT1YPx48dDJpPh4MGDuH79erXr7dixA/fu3UPr1q01Ths5ffp0lZpSqcTZs2cBqF9FoTz01eToVYcOHaBSqdTmz1bet1KpRMeOHbXeXk306NEDbdq0wd27dx95m2yVSiXOmS1/zpruMKlQKMTXpq76Lpeamork5OQq9fK+Ku+//Gijpk9MLl68qHH7DxtPb29vSKVSjePWFPj4+ACAOJa14dy5cxpfS03jBQA2NjYYOnQoYmJicPbsWYSFhYl32K0tCoVC/BSjvLfs7Gzk5eWha9euVcJ4YWEhLl26VGU75W9mq/tkytfXF4Ig4MSJE7XWe20oP2+lfPraw/z999/47LPP0L59e3zxxRca38CbmpqiXbt2uH79uvgpC1FDxUBOVA9cXFzw2muvQS6X44033tB48tnBgwexbNkyyGQyLFq0SOP81sjISBw5ckSttnnzZiQmJiIgIEBt/nj5JcY0ncxYnQkTJgAAPvvsM7W7eBYXF4uXO3zUJQkfl1QqxeLFi6Gnp4elS5fir7/+0vgP840bN/Dyyy8jLS0NwP0T8aysrLB79+4qRws3bNiApKQkBAUF1fmNkJRKJT799FO1kJeUlIRNmzZBT08Po0ePFuudO3eGVCpFWFiY2uuck5OD//u//9O4/YeNp62tLUJCQnDx4kV88803GqfUJCYmIikp6XGfnk6NHz8eFhYWWL16tcYTCFUqFaKiomq0zfj4eGzZskWtdvDgQURHR8PNza3KCcJAxcmdb731FoqKivDMM89o/D19XJs3b4ZcLoeVlZV4rwJbW1sYGxvj0qVLalOO5HI5li1bhuzs7CrbsbCwgEQiqXaK3AsvvAAAWLFihfh7VJmmWm0ICwvDqVOnNL4RSk9PF08Y1/TaV3bhwgW89957aNGiBdasWfPQT+2mTp0KuVyOBQsWaPz0KTc3V+ObGqL6xikrRPVk1qxZKC4uxs8//4wxY8agV69eaNu2LRQKBc6fP4+YmBgYGRnhs88+Q2BgoMZt9O/fHzNnzsSgQYPg5uaGK1eu4NixY7CysqrykW1gYCB++uknfPDBBxg6dChMTExgYWEh/mOsSUhICA4dOoS9e/di5MiRGDRokDhPNTk5GcOHD1cLlrWtR48e+Prrr/Hee+/hvffew7fffouAgABYW1ujoKAAFy9eRExMDIyNjcWP2k1NTbFs2TLMmTMHL7zwAoYNGyZeh/zkyZOwt7fHkiVL6qzncl5eXoiNjcX48eMRHBwsXoc8Ly8Pc+fOhaurq7huixYtEBISgr/++gtjx45F3759UVBQgOPHj6N79+4aTwDt2bMnpFIpVq1ahevXr4tH2adPnw4A+N///oeEhAR89dVX2LVrF/z8/GBnZ4d79+7h5s2b+Oeff7Bq1SqNJ542dNbW1vjqq68wY8YMPP300wgMDETbtm0hlUqRmpqK8+fPIycn56Hz5x/Uu3dvrFixAsePH0f79u3F65AbGhpi2bJlGoN2t27d0L59e1y5cgX6+vriG9iaysvLUzs5taCgAHFxcYiOjoZUKsWiRYvEKWNSqRSTJ0/G2rVrERISgoEDB0IulyMqKgq5ubniVVYqMzU1hY+PD86cOYN33nkHrVu3hlQqxYABA9C+fXv06tUL06dPx7fffovhw4eL1yHPyMjA2bNn4evrixUrVjzWc3uYmJgYbNy4Efb29vDz8xPvDZCcnIxjx46hpKQEAwcOVDsxU5MFCxagtLQUPj4+Gq/6ZG5ujqlTpwK4fwDh0qVL2LJlCwYPHoxevXrB0dERubm5SE5OxunTpzF+/Ph6+RtB9DAM5ET1RCqVYv78+RgxYgR++eUXnD59GhEREZDJZGjVqhVefvllTJky5aGX/RsyZAieeeYZfP/99zh27Bj09PQwZMgQvP3222jdurXaur1798b8+fPx22+/Yf369ZDL5WjVqtVDAzkArFq1Cv7+/tixY4c4T9bDwwMvv/yyeISwLg0YMAAHDhzAli1bcOLECezbtw8FBQUwNTVFmzZt8Oabb+KZZ56Bra2t+JhBgwZhy5YtWLNmDU6ePImCggLY2dlh0qRJmD59+hOfdKcNS0tL/PDDD/i///s//PHHHygoKEDbtm3x8ssvIyQkpMr6S5cuha2tLXbv3o0tW7bA0dERkydPxiuvvIK9e/dWWd/DwwMrVqzAunXrsGXLFvFuluWB3MzMDJs2bcJvv/2GsLAw7N+/H6WlpbCzs4Obmxvef//9Kjd7aUwCAwOxa9curFu3DidPnsSZM2egr6+PFi1aoGfPnhg6dGiNtufj44MZM2bgyy+/xObNmyEIAnr27Ik5c+bA29u72seNHz8ey5cvx4ABA6o9MfRRyi97WK78aiUjR47E1KlTq+x/9uzZsLGxwfbt27Ft2zaYm5sjKCgIc+bM0XjVGeD+DZk+/vhjnDx5Ert374YgCGjZsqU4B3/27Nnw9fXFxo0bcfToURQVFcHW1hadO3fGmDFjHut5PcrLL78Md3d3hIeH4+rVqzh58iTKyspgZWWFHj16YNSoUQgJCXnkFVZKSkoA3L9R2v79+6ssb9WqlRjIAWDRokXo06cPfv31V4SHh4sntTo6OuKVV16p04MMRNqSCNpM1iIinfrjjz/w/vvv4+OPP65yLWDSPS8vL/To0QObNm3SdStUx+bPn48///wT69evr/aTLCKimuIcciIiIi2kpqZi9+7d8PDw0HjdeyKix8UpK0RERA8RGhqK+Ph47N69G2VlZZg9e3aNb2BFRPQwDOREREQP8dtvv+H06dNwdHTE+++/X+P56kREj8I55EREREREOsQ55EREREREOsQpKwDS0/PrfZ9WVibIySmq9/1S/eI4Nw8c56aPY9w8cJybB12Ns729ebXLeISciIiIiEiHGMiJiIiIiHSIgZyIiIiISIcYyImIiIiIdIiBnIiIiIhIh3iVlYcoKytBfn4O6uJS7Tk5UigUqlrfLmkmkUhgbm4FAwMjXbdCREREpIaBvBplZSXIy8uGtbU9ZLLaf5lkMimUSgby+qJUKpCdnQ4LC2uGciIiImpQOGWlGvn5OXUWxqn+yWR6sLa2R35+rq5bISIiIlLDQF4NQRAYxpsYmUwPgsBPJYiIiKhhYSAnIiIiItIhBnIiIiIiahakUgkkkvv/b0gYyBuon35ag169umPSpHEalz/zzFj06tUdP/20RuttxsVd1Lj+Tz+twciRAx+710e5desGevXqjnPnztTZPoiIiIgeRiKTILdEgb0R8cgtUUAiazihnIG8ATMwMERq6h1cuRKnVr98+RLu3k2FgYFhjbZ3+fIl/PzzD7XZIhEREVGDl11Qinu5pXjr82NYu/Mi3vr8GPKKlQ3mSDkDeQNmbGwEP7/uOHhwv1r94MH96NbNH8bGvHwfERERUXXuZhXhp7A4bPj7KmJvZED1761lVAJw6VYGZLKGEYV13sX+/fsxZcoUdOvWDV5eXlWWFxYWYunSpQgODoa3tzdCQkJw5coVteXz58+Hn58fAgICsGLFCiiVyvp8CnVq4MAhOHz4gHhzIkEQcOTIQQwcOKTKujExFzBz5jQMHBiMESMG4pNPlqKoqBAAsGdPKD7//P8AAL16dUevXt0xc+Y0tcdfu3YF06ZNxcCBwXjppecQE3NebblSqcRPP63B+PEj0b9/IF544Wns3/93lT7++GM7xo8fiUGDeuG9995CZmZGrbwWRERERNpITi/A939dxMIfInHq4l3cyShAB3cblB8Ql0qAzh52DeaeMDq/rl9xcTF69uyJoKAgrFq1Sm2ZIAiYOXMmlEolvvzySzg4OCAxMRFmZmbiOkuWLMHFixexfv16FBYWYu7cuTAzM8PMmTPr+6nUib59B+Czz1YgNvYCfHy6IibmPHJystGnT398++2X4nqxsRcwZ84b6N27H5Yu/QS5ubn4/vvVyM/Pw9KlKxEY2AuTJr2AX3/djO+//xkAYGpqKj6+pKQEy5Z9iKeffg42Nrb4+ecfsGDBu9ixYzeMjO4fif/xx++xZctGvPTSq+jQoROOHj2MJUv+C4kEGDx4GADgxImjWLXqE4wdOwG9e/fDhQvn8PHHH9Xb60VERETNV8LdfISGx+PctXSxJgHg7mAOE30pPn+rHy7dzkTnNrYwN5JBpaz9u7E/Dp0H8jFjxgAAoqKiqiw7cuQILl26hMOHD4sh3MXFRVyem5uL0NBQrFu3Dt7e3gCAOXPmYNWqVZg+fTqkUp1/APDEzM3NERAQiIMH98PHpysOHtyPgIBAmJubq633/fer0bmzN5Ys+Vis2du3wOzZb+DWrRto06YtHB0dAQCdO3epsp/S0lK8+eY76NbNHwBgZ2eHl156HhcunEPPnkHIy8vF9u1bMWXKK5g69T8AgICAQKSnp2HdurViIN+4cR0CAoLw7rvvi+vk5GQjNHRnrb82RERERABw804uQk/FI/ZmpliTSICADg4YGeSOVnb3D0JKpRIM7+mG3NziBhPGgQYQyB/m6NGj6NSpE7766ivs3r0bNjY2eO655/Dss88CAC5dugSJRAJ/f3/xMYGBgcjMzERycjJcXV212o+VlUmVWk6OtM7nFT1s+/dPMpBAJpNi8OBh+OKLTzFnzjs4duwQ3nrrvX8fK4FUKoFcXopLl/7B22+/p3bjm65d/aCnp4dr166iXTtPSCQSjfuVSiXQ09ND9+7+4psYD4+2AIDMzHTIZFLEx99CSUkJBg0aovb4QYOGYunSRcjNzYGlpSWuXbuGt99+T22d/v0HIjR0J2Syun9NH0VPT6pxvOuKTFa/+yPd4Dg3fRzj5oHj3PhcupWJ7YevI/ZGxfRYmVSCvl2dMb6/B5zszKo8RiqVwsLCuD7bfKQGHchTUlJw+vRpWFpaYs2aNbh+/ToWL14MS0tLjBgxApmZmbC0tIRMJhMfY2NjAwDIzMzUOpDn5BRVqSkUqjqdVySTSR+6fZVKACBAqVQhKKg3Pv54Cb77bjWKi4sRGNjr38cKUKkE5OTkQqlU4v/+72P83/99XGVbd++mQqlUifPQH9yvSiXA1NQUglCxTCq9/5qWlJRAqVQhPf3+Rz+WllZqj7eysgYA5ObmQKFQQKlUwMpKfR0LCytxv7qeq6VQqDSOd12xsjKp1/2RbnCcmz6OcfPAcW4cBEFAXEI2Qk/F41pSjljXk0nQq4sjRvR0g53V/cCtaTx1Nc729ubVLmvQgVwQBOjr62P58uUwMTFB586dcfnyZezYsQMjRowQA2Zl5UeBmxJjY2MEBfXGb79tQf/+A2FsrP6uzszMHBKJBC+/PA2BgcFVHm9nZ//EPdja2gEAsrOzYWlpJdazs7MAAObmlrCwsIBMJhNrD65DRERE9LgEQUDszUyEhsfj1p08sa6vJ0VfHycMC3CFjUXjvAJdgw7ktra2cHBwgIlJxcdHrVu3xsmTJwHcn+ecm3v/6HD5UfLMzEzxsU3J2LETIJeXYcyYCVWWGRsbo1OnLkhMTMBLL71a7Tb09PQB3J8vbmhYs2uYt2njASMjIxw5clBtH4cPH4CLiyusre8fKW/XzgsnThzH2LFPiescP36kRvsiIiIiKqcSBJy/lo7Q8HgkphWIdUN9Gfr7tcLQHq6wNDXQYYdPrkEHcl9fXxw8eBAlJSXilT4SExPFkxM7duwIQRBw5swZBAQEAAAiIyNha2sLZ2dnnfVdF/z8usPPr3u1y994403MmfMGpFIJ+vUbCBMTU6Sl3UV4+ElMmzYdrq5ucHNzBwBs374V3br5w9TUFK6u7lrt38LCEhMnPosNG36CTCZD+/YdcezYYUREnMKHHy4T15s8+SUsXDgXn376Mfr06Y/z588iKiriSZ46ERERNUMqlYDTV+4hLCIeKemFYt3YUIaB3ZwxuLsLzE0adxAvp/NAnpOTg9TUVCQmJgIALl++DADw8PBASEgIVq9ejQ8//BDTpk3D9evXsW3bNqxYsQIAYGVlhVGjRmHp0qVYtmwZioqK8MUXX+C5555rEldYqQkfH1+sXv0DfvppDT76aBFUKiVatnREQEAgbGxs/12nK557bjK2b/8Va9Z8Ax+frli9eq3W+/jPf16Hnp4edu7cgaystXB2dsH//vcRBg0aKq7Tt29/vPXWXGzevAF794aha9dumD//A7z9dtO4DCURERHVLYVShai4NIRFJCAtq2Kut6mRHgb7u2BQN2eYGOnrsMPaJxE0TcSuR3/88Qfef//9KvVDhw7B2dkZcXFxWLJkCeLi4uDo6IiXX34ZzzzzjLheYWEhlixZgv3790NfXx/jxo3De++9p3ai56Okp+dXqWVkpMLOzvHxnpQWHnVSJ9WNuh7XB/EEoeaB49z0cYybB46zbskVKpy6mIo9EQnIyC0R6+Ym+hjWwxX9uraCseGTH0tuiCd16jyQNwQM5M0HAznVBY5z08cxbh44zrpRJlfiRGwq9kQmIDu/VKxbmhlgeIAb+vo6wVBf+wOtj9IQA7nOp6wQERERUfNTWqbEkfMp2BediNzCMrFua2GIET3d0MvbEfp6tRfEGzIGciIiIiKqN8WlChw+l4x90UkoKJaL9RZWxhgR6Iagzi2hp+MbCdY3BnIiIiIiqnOFJXIcOJ2Eg2eSUVSqEOuOtiYYFeiOHh1bQNbMLspRjoGciIiIiOpMXlEZ9kcn4fC5ZJSUKcW6s70ZQoLd0c3THlJp07uxY00wkBMRERFRrcspKMXfUYk4eiEFZfKKC1m4tzRHSJA7fNrZQdoE77D+OBjIiYiIiKjWZOWVYE9kAo7HpEJR6YpybVtZIiTYHZ1b20DCIK6GgZyIiIiInti9nGLsiYjHqX/uQqmquKp2e1crhAS5o72bNYN4NRjIiYiIiOixpWYWYndEAiIvpUFV6fY2nVvbICTYHe2crXTXXCPRPE9lpXrXq1d3nDt3BgBw7twZ9OrVXVz2009rMHPmNF21RkRERI8hOb0A3/91Ef/9IQrhF++KYdy3rR0+mNIdbz/jyzCuJR4hb0Li42/jhx++xblzZ1FaWgo3NzdMnPgsRowIqbcezp07gzfffB0nT56pdp0uXXzw119/11tPREREVHsS7uYjNDwe566lizUJgG5e9hgV5A5Xh+rvSEmaMZDXsevJObiXXQwHaxO0dbass/3cvHkD06e/gsDAXvjii29hbm6OqKgIrFr1CdLS7uKll16ts33XlL6+Pmxt7XTdBhEREdXAzZRchIbHI/ZmpliTSICAjg4YGeiOVnamOuyucWMgr0O/HLiKE7GpkAAQAPT2dsTzg73qZF+ff74Sbdp4YNGipeIJE+PGPQWJRILPP1+JIUOG4++/d+P8+bNYvXqt+Lhlyz4EACxceP//mzb9jL17w5CWdhf29i0wYcIzmDhxkrj+zJnT0LmzN3Jzc3Dw4H5YWVnhjTfexIABg5Caegdvvvk6AIhTUhYsWFTlCH11R9E3bVqPbds2Q6FQYsKEp/Hqq2/U6mtERERENXc1MRu7TsXjckK2WJNJJQjs3BIje7rBwcZEh901DQzkNXDrTh5CT91Wu6h9dYpKFUhOL0Clcxtw+FwKriflwthQDxIJ1JY9yMhAhpDg1mjjZPHIfeXk5ODChXNYvHh5lbOXR40ag2+//QonThx95HaA+0ev5837APb29rhy5TI+/ngJnJ2dERjYS1xn587f8fLLr+Hnn3/B3r1hWL78Q/j5dUeLFg5YtmwlFi58T5ySYmZmptV+r169Aisra3z99VrEx9/Cxx9/BFdXNwwdOkKrxxMREVHtEQQBcfHZCD11G9eSc8W6nkyCXt5OGBHgCjsrYx122LQwkNfAgTNJiKn0MU1NCQKQeK9A6/WNDfUwbXSnR66XkpIMAHB1dauyTE9PD05OrZCcnAxra+tHbmvSpBfEr52cWuHChbM4cuSQWiD38emKp59+FgDw0kuv4tdfN+PKlTj07BkEc/P7byBqOiVFEFSYP/8DmJmZoXXrNrh+/Rp27PiNgZyIiKgeCYKAmJuZCAuPx607eWJdX0+Kvr5OGB7gBmtzQx122DQxkNfA4O4uKClVPPYRcokEcLE30/oI+WB/F636EsQNab62pyAI0NPTbqgjIk5h06afkZSUiJKSYsjlcvj6+qmt06ZNW/FrPT09WFlZIzs7S6vtV8fV1U3taHrHjp3wxx/bn2ibREREpB2VIODc1XSEhcerHTw01JdhgF8rDOnhCktTAx122LQxkNdAGycLzJ7oo/X6VeeQO+H5wZ4AAJlMCmWlu1c9CWfn+8E9IeE22rXzVFumUCiQmnoHI0eORmFh1aPzCoVCDOt37qRgwYJ38cILU/Hmm2/D1NQMv/66GQkJ8WqPeTDcSySSSm8KHhdvFEBERFTfVCoB0VfSsDs8ASkZhWLd2FCGgd1cMMTfBWbG+jrssHlgIK9Dzw/2QkCHlkjLLqrTq6xYWVnB19cPv/++DQMHDlGbRx4W9hdKS0vQv/9AnDx5HJmZGWqPvXXrBjw92wMArl69DBMTE7zyymvi8tTUOzXqpTysK5VKyGQyrR+XlJSAwsICmJreP0p++XKcxik4RERE9OQUShUiL6Vhd0Q80rKLxbqpkR6G+LtgYDdnmBgxiNcX3hiojrV1tkRwF8c6veQhALz11nu4ffsmFi/+L65fv4rU1Dv488/fsXr153j99Vmwt28BHx9fJCcn4a+//kBSUiLWrPkGqamp4jZatXJGXl4e9u4NQ3JyEjZuXIeLF/+pUR8ODi0BAFFREcjJyUFZWZmWj5Tgk0+WIT7+No4dO4zff/8V48dPrNG+iYiI6OHkChWOnk/BgrWRWLfnshjGLUz0MbGfB1a+EYSQ4NYM4/WMR8ibCA+Ptvj++5/xww/fYdas11FQkA/g/uUMhw8fBeD+3O9Zs97CunVr8d13X2HMmAno06efuA1Pz/aYNm06vvnmS5SVlaF//4EYN+4pXLqkfSh3cGiJyZNfwvLlHyInJ0fjZQ818fJqDw+Ptpgx4z9QKpUYP/5pntBJRERUS8rkShyPuYO9UYnIzi8V61ZmBhge4IY+vk4w1Nf+k22qXRLhySf/Nnrp6flVahkZqbCzc6yzfdbmHHJNSktL8M47b0KlUuHzz1fD0NCozvbVmNT1uD7IysoEOTlF9bY/0g2Oc9PHMW4emuI4l5QpcPT8HfwdnYi8wopPrW0tjDAi0A29urSEvl7zCuK6Gmd7++rvYMoj5E2UoaERVq78HL/9thWXL8dVuVIKERERNV1FJQocPpeM/aeTUFAsF+strIwxMtANgZ1bQk/GmcsNBQN5E2ZiYoqpU/+j6zaIiIionhQUy3HwTBIOnklGUalCrDvammBUkDt6dGgBmZRBvKFhICciIiJq5PIKy7D/dBIOnUtGaaX7pbi0MENIkDv8vOwhlfASww0VAzkRERFRI5VTUIq/oxJx9HwKyhQV56a5tzRHSLA7fNvaqV0OmRomBnIiIiKiRiYztwR7ohJwIiYVikoXiWjrbInRQe7o1NqGQbwR0Xkg379/P3755RdcvHgRBQUFuHr1qsb1Dh48iBkzZmDcuHFYsWKFWC8sLMRHH32E/fv3Q19fH+PGjcPcuXNrdFMaIiIiosbgXk4x9kTE49Q/d6FUVVwor72rFUKCW6O9qxWDeCOk80BeXFyMnj17IigoCKtWrdK4TlZWFj7++GP4+VW9UsiSJUtw8eJFrF+/HoWFhZg7dy7MzMwwc+bMum6diIiIqF6kZhYiLDwBUXFpUFW6YnXnNjYICXJHO2cr3TVHT0zngXzMmDEAgKioqGrXWbx4MSZPnowrV66o1XNzcxEaGop169bB29sbADBnzhysWrUK06dPh5RnERMREVEjlnyvAKHh8Thz5R4q3zimazs7jApyR2tHC531RrWnwSfWsLAw3Lt3Dy+++GKVZZcuXYJEIoG/v79YCwwMRGZmJpKTk+uzTdJSWVkZ/vvfeRg8uA+GDesHAOjVqzvOnTuj28aIiIgakPi7efh6Ryz+ty4ap/8N4xIA3du3wIcv+WPWBG+G8SZE50fIH+bevXtYuXIlNmzYoPFod2ZmJiwtLdXmi9vY2IjLXF1dtdqPlZVJlVpOjhSyOr5gfm1sPzDw4Tf8+eOPMDg6Oj3xfmrL8eOHERt7AT/9tBGWllbiayCT1f3rDQB6elKN411XZLL63R/pBse56eMYNw8NYZyvJmRj++FrOHc1XaxJJUBv31aY0L8tnFtUf7dH0k5DGOcHNehA/r///Q9Tp05F69atNS4XBKFK7XFOZNB0+1SFQlWnt7aXyaS1sv2//vpb/Hrr1s24eDEWy5atFGtWVtZ1+jy0pVTevyZqcnIyXF3d4Orq/m9dJf6/PvpUKFT1ervcpngbZqqK49z0cYybB12NsyAIuJqYg9DweFxOyBbrMqkEQZ1bYkSgGxys7wdI/hw+OV2Ns7199W+mGnQgP3PmDI4fP45PP/0UAKBS3Q9su3btQlxcHOzs7JCbmwulUikeJc/MzAQA2Nra6qbpSgR5CVQ5dyGzd4cyPR5Sq5aQ6BvV6j5sbe3Er42NjaGnpyfWSkpK8MUXn+LIkQNQKBTw9u6Kt9+eh5YtWwIAli37EIIgwN6+Bf7883cYGRnh+eenYOLESQCA0tJSfPHF/+HEiWMoKipCy5Yt8frrs9CnTz8AQHR0JL755gskJibAwaElXnnlNQwePAwAkJp6BxMnjsZHH63Apk3rcfPmdfTrNwCHDh0AcH+ayvDho7Bw4YdVntPDtvvee2+hSxdvTJ78EgDgpZeeg1yuwObNvwG4/6YkMvIUvvzyu1p9nYmIiGqbIAi4FJ+F0FPxuJ6cK9b1ZBL09nbC8J6usLM01mGHVF8adCDftm2beGQVAL744gsA90/cBICOHTtCEAScOXMGAQEBAIDIyEjY2trC2dm5vttVI8hLULTrY6iykqDn7gdF/DlIbVxgMvr9Wg/l1fm//1uO7OxsfPrpVzAxMcHmzRswf/7bWLduszgF6Pjxo5gw4WmsXbse586dxmeffYJu3fzRpo0Hfv/9V1y5Eof/+78vYGlphYSEeBgYGAAA7t69i/nz38bzz0/B4MHDcPp0JJYuXQRnZxd06NBJ7OGnn9Zi9ux34ODQEjY2trC3dxCP4hsaVn0dHrVdb28fXLhwDpMnv4SiokIkJSVCIpEiNzcHlpZWiI29AG9v33p5fYmIiB6HIAiIuZGJ0PB43E7NE+sGelL09W2FYQGusDY31GGHVN90HshzcnKQmpqKxMREAMDly5cBAB4eHvDw8FBb18Li/skLnp6eAAArKyuMGjUKS5cuxbJly1BUVIQvvvgCzz33XJ1cYUV57xZKz/0FyEseua4gL4EqMwEAoLh9FoAAVWYCikI/vh/IJRJAw5Qbkb4RDP3GQNaizWP1mpp6B0eOHERo6H6YmpoBAN57byGGDeuHuLhL6Ny5CwDA0dERr702AwDg6uqGX3/dgtjY82jTxgP37qXBy6uDGLCdnFqJ29+583d4erbHK6+8Jj42NvYCtm3bgg8/XCau9+KLL8HfP0D8/sGj+A961Ha9vX2xefN6qFQq/PNPLDw928PAwACxsRfQu3c//PNPDMaPn/hYrxkREVFdUgkCzl1NR2h4PJLuFYh1QwMZBnRthSE9XGFpaqDDDklXdB7IDx8+jPfff1/8fuzYsQCAQ4cOaXWUe9GiRViyZAmmTJki3hjojTfeqJNey/7ZD2VizGM8siJ4qzIStN+fgTGMB7z+GPsDbt++BblcjrFjh6vVS0tLcedOihjI27Rpq7bczs4O2dn3568NHToCb701A9evX0OPHj3Rv/9AeHq2BwAkJMSjU6fOao/t1Mkbf/8dplZr186rRn0/arsdOnRCWZkcN29eF4+GGxoaIibmAtzc3JGfn4dOnbrUaJ9ERER1SaUSEH05DWERCbiTUSjWjQ31MKibMwb7u8DMWF+HHZKu6TyQjx8/HuPHj9dq3cp36CxnamqKTz75BJ988kltt1aFQZchEOTF2h8hF8O3BOWhXGrnpvURcoPOQx671+LiIpiYmOCnnzZXWVZ+JRoA0NOr+iNQPle/Y8fO2L59F8LDTyIqKgKvv/4KXn99Bp5++jkAD+m9EiOjmk7Pefh29fX10b59B8TEnEds7AU8++xkGBkZ4bvvvoa7uzvatfOCiUnDOnOaiIiaJ4VShYhLd7EnIgFp2cVi3dRID0N6uGKgXyuYGDGIUwMI5I2JrEUbmAx7S6t1q51DHnJ/DnltXWWlOm3beqKwsBAKhQLu7pqvUqMNCwtLDBs2EsOGjcQvv2zA7t278PTTz8HV1R0xMefV1r10KVa8esrj0ma73t6+OHfuLK5cuYwuXXygr6+P27dvIjo6Cj4+vk+0fyIioiclV6hw6p9U7IlMQEZuxUE8CxN9DA1wRf+urWBkwAhGFfjTUEck+kYwGf1+nV9lpTpubu7o27c/PvhgHmbNehvOzi5IS7uLw4cPYtq06TA3f/R1TLdt+wX29g5o184TZWVliI6OgovL/Wu7jxv3FH77bQt++mmNePLl0aOH8e23Pz1R39ps19vbF1u3boK7e2vxeXh4tMOxY4exZMnHT7R/IiKix1UmV+JYzB38HZWI7PxSsW5tbohhAa7o4+MEQ33ZQ7ZAzRUDeR2S6BtBZu8OAOL/69P//rcUa9d+i+XLFyM3Nwd2di0QENBTvFLKoxgZGWPDhh+RnJwEQ0MjdOvmjzlz3gUAtGzpiOXLP8V3332FTZt+hoNDSyxYsKjK/O+a0ma7Xbr4QBAEdOniK9Z8fHxx6dI/vMIKERHVu5IyBY6ev4O/oxORV1gm1m0tjDAy0A3BXRyhr9fgb45OOiQRNN1dp5lJT8+vUsvISIWdnWOd7bOup6yQZnU9rg/izUSaB45z08cxbh5qOs5FJQocOpeMA6eTUFAsF+strI0xMtANgZ1aQq8e7kJNNcMbAxERERE1cgXFchw4nYSDZ5NRXKoQ6052phgV6Ab/Di0gq4PLL1PTxUBOREREpIW8wjLsO52Iw+dSUFpWceNClxZmCAlyh5+XPaQSiQ47pMaKgZyIiIjoIbLzS/F3VCKOXUhBmaJiumlrR3OEBLWGT1tbSBjE6QkwkBMRERFpkJFbjL2RiTgRewcKZcUpd22dLTE6yB2dWtswiFOtYCAnIiIiquRedhF2RyQg/OJdKFUVQbyDmzVCgtzh5WrFIE61ioG8GhKJBEqlAjIZX6KmQqlUQCLhSTZERKRZ8r0CbN13GZFxaWo30+7SxhYhQe5o62ypu+aoSWParIa5uRWys9NhbW3PUN4EKJUKZGenw8LCWtetEBFRA5N0rwBh4fE4c/WeWhDv2s4Oo4Lc0drRQnfNUbPApFkNAwMjWFhYIycnE4JQ+9cL19OTQqHgdcjri0QihYWFNQwM6udOqURE1PDdTs1DWHg8zl/PEGsSAN3bt8CoIHe4tDDTXXPUrDCQP4SBgRFsbesmwPEmE0RERLpxIzkXu8Jv4+KtLLEmlUjQ29cJQ7o7w9HWVIfdUXPEQE5ERERNniAIuJKYg7DweFxOyBbrMqkEQZ1bYmSgGzxb2/FgGekEAzkRERE1WYIg4NLtLOwKj8eN5FyxrieToLePE0YEuMHWktMZSbcYyImIiKjJEQQBF25kICw8HrdT88W6gZ4U/bq2wtAerrA2N9Rhh0QVGMiJiIioyVAJAs5dTUdoeDyS7hWIdUMDGQb4tcJQf1dYmBrosEOiqhjIiYiIqNFTqlSIvnwPYeHxSM2smAdubKiHwd2dMai7C8yM9XXYIVH1GMiJiIio0VIoVYi4eBe7IxNwL7tYrJsZ62OIvwsG+DnDxIhxhxo2/oQSERFRoyNXqHDyn1TsiUhAZl6JWLcwNcCwHq7o19UJRgaMOdQ48CeViIiIGo1SuRLHL9zB3qgE5BSUiXVrc0MMD3BFHx8nGOjLdNghUc3VSiDPzc2Fvr4+TExMamNzRERERGpKyhQ4cj4F+6ISkVckF+t2lkYY0dMNwV0coa8n1WGHRI9P60AeERGBEydO4LXXXoOlpSUAIDMzE7Nnz8bZs2chk8nw/PPP4/3336+zZomIiKh5KSpR4NDZJOw/nYTCEoVYd7A2xshAd/Ts5AA9GYM4NW5aB/JNmzbh+vXreO+998TaJ598gjNnzsDNzQ2FhYXYuHEjfHx8MGLEiDpploiIiJqHgmI59p9OwqGzySgurQjiTnamGBXohh4dHCCVSnTYIVHt0TqQX7lyBT169BC/Lykpwb59+xAcHIyffvoJBQUFGD16NH799VcGciIiInoseYVl2BediMPnU1BaphTrri3MMCrIHX5e9pBKGMSpadE6kGdlZaFFixbi9zExMSgtLcW4ceMAAGZmZujXrx8OHDhQ+10SERFRk5adX4q9UQk4fuEOyhQqsd7a0QIhwe7w8bCFhEGcmiitA7mBgQFKSiouK3TmzBlIJBL4+/uLNTMzM+Tm5taogf379+OXX37BxYsXUVBQgKtXr4rLoqKi8NNPPyE2NhZyuRydO3fGe++9h06dOonrFBYW4qOPPsL+/fuhr6+PcePGYe7cuZDJeIY1ERFRQ5eRW4y9kYk4EXsHCqUg1ts5WyIk2B2d3G0YxKnJ0zqQOzs7IzIyUvx+//79cHNzg4ODg1hLTU2FtbV1jRooLi5Gz549ERQUhFWrVqktu3DhAnx8fDBz5kyYm5tj3bp1eOWVV7B3715xP0uWLMHFixexfv16FBYWYu7cuTAzM8PMmTNr1AcRERHVn7TsIuyOSEDExbtQqiqCeAc3a4wOdoeXa83yBFFjpnUgHzt2LJYvX46JEydCX18f165dw4wZM9TWiYuLQ+vWrWvUwJgxYwDcPxr+oNdee03t+w8//BC7d+/GuXPnMHDgQOTm5iI0NBTr1q2Dt7c3AGDOnDlYtWoVpk+fDqmUZ10TERE1JHcyChEWEY+ouDQIFTkc3h62GBXkjratLHXXHJGOaB3In332WcTExGDPnj0QBAH9+/fHtGnTxOWxsbG4efMmRo4cWSeNAvePppeWlsLCwgIAcOnSpSrTZgIDA5GZmYnk5GS4urpqtV0rq/q/frpMJtXJfql+cZybB45z08cxfnK37+Rhx5HriLiYqhbEe3R0wMQB7eDhbKWz3spxnJuHhjjOWgdyfX19fPbZZ1i8eDGA+/PFK3N2dsbOnTvRqlWr2u2wktWrV8PV1RVdu3YFcP866JaWlmrzxW1sbMRl2gbynJyi2m/2EaysTHSyX6pfHOfmgePc9HGMH9/t1DyEnorHhRsZYk0CwL9DC4wKdIdzi/t5oiG8vhzn5kFX42xvb17tshrfqfPBIF7OxsZGDMN1Yfv27fj999+xefNm6Ondb1uo/Bb7Xzzxg4iISPeuJ+cgNDweF29liTWpRIKenRwwMtANjramOuyOqGGpcSDXhT179mD58uVYs2YN2rdvL9bt7OyQm5sLpVIpHiXPzMwEANja2uqkVyIiouZKEARcScxB6KnbuJKYI9ZlUgmCu7TEiJ5uaGHdsKYKEDUE1QbygQMHPtYGJRIJDh48+NgNPejw4cNYsGABvvzyS7UbEwFAx44dIQgCzpw5g4CAAABAZGQkbG1t4ezsXGs9EBERUfUEQcDF21kIDY/HjeSKyx/ryaTo4+OI4QFusLU00mGHRA1btYFc03QQuVyO9PT0+w/U04OVlRVycnKgUNy/pa29vT309fVr1EBOTg5SU1ORmJgIALh8+TIAwMPDA2fPnsXs2bMxd+5cdOzYUdy3iYkJTE1NYWVlhVGjRmHp0qVYtmwZioqK8MUXX+C5557jFVaIiIjqmCAIuHA9A6Hh8Yi/my/WDfSl6OfbCkN7uMLa3FCHHRI1DhJBU/LWoKCgAFOnToWenh7efvttdO/eHVKpFCqVCqdPn8aqVaugUqnw888/VzvPXJM//vgD77//fpX6oUOHsHr1avz5559Vls2cOROzZs0CcP/GQEuWLFG7MdB7771XoxsDpafnP3qlWsYTR5oHjnPzwHFu+jjG6lSCgLNX0xF6Kh7J6QVi3dBAhoF+zhjSwwUWJgY67PDxcJybh4Z4UqfWgfyjjz7CyZMnERoaCgODqr9kpaWlCAkJQZ8+ffDf//738bvVAQZyqisc5+aB49z0cYzvU6pUiI67h7CIeKRmVrweJoZ6GNTdGYO6u8DMuGaflDckHOfmoSEGcq1P6jxw4ABGjhypMYwDgKGhIQYOHIjdu3c3ukBORERE1VMoVYi4eBe7IxJwL6dYrJsZ62OIvwsG+DnDxKhRXCeCqEHS+ren8lzx6sjlcuTk5DxpT0RERNQAyBVKnIxNxZ7IBGTmlYp1C1MDDOvhin5dnWBkwCBO9KS0/i1ydXXFvn378Oabb8LcvOoh99zcXOzbtw8uLi612iARERHVr1K5Escu3MHfUQnIKSgT69bmhhge4Io+Pk4w0Nf+XC0iejitA/mkSZOwdOlSPPXUU3jjjTfQvXt32NnZISMjA6dPn8b333+PjIwMvP7663XZLxEREdWR4lIFjp5Pwb7oROQVycW6naURRgS6IbizI/T1eBUzotqmdSB/4YUXEB8fj82bN2u8KoogCHjhhRfw/PPP12qDREREVLeKSuQ4eDYZB04nobCkYnqqg7UxRgW5I6CjA/RkDOJEdaVGE7/++9//YuTIkdixYwfi4uJQUFAAMzMzdOrUCePGjYOfn19d9UlERES1rKBYjv2nE3HobDKKS5VivZWdKUYGuaFHewdIpRIddkjUPNT4TIyuXbuia9euddELERER1YPcwjLsi07EkXMpKJVXBHFXBzOEBLmjq6c9pBIGcaL6wlOjiYiImons/FLsjUzAsZg7kCtUYr2NkwVCgtzh7WELCYM4Ub2rcSBXKpW4ffs2cnNzoVKpNK7j7+//xI0RERFR7cjIKcaeqEScjL0DhbLifoCezpYICW6Nju7WDOJEOlSjQP7NN99gw4YNyM9/+J0tL1++/ERNERER0ZNLyy7C7vAERFy6C6WqIoh3dLdGSJA7vFytddgdEZXTOpD/8MMP+Prrr2Fubo4xY8agZcuW0NPjjBciIqKGJiWjELsj4hEVlwahIofD28MWo4Lc0baVpe6aI6IqtE7U27dvh4ODA/7880/Y2NjUZU9ERET0GBLT8hEWHo+zV9NRKYfDz9MeIUHucGtZ9cZ+RKR7Wgfy1NRUPP300wzjREREDczt1DyEnorHhRsZYk0CwL9DC4wKdIdzCzPdNUdEj6R1ILezs4NCoXj0ikRERFQvriXlICw8HhdvZ4k1qUSCnp0cMDLQDY62pjrsjoi0pXUgHzZsGA4ePIiysjIYGBjUZU9ERERUDUEQcCUhG6Hh8biSmCPWZVIJgrs4YkSgG1pYGeuuQSKqMa0D+ezZsxETE4M333wTCxcuhIuLS132RURERJUIgoB/bmUhLDweN1JyxbqeTIq+Pk4YFuAKW0sjHXZIRI9L60A+cuRIKBQKnD9/HseOHYO5uTnMzaueHCKRSHDw4MFabZKIiKi5UgkCYq5nIDQ8HvF3Ky47bKAvRT/fVhgW4AorM0MddkhET0rrQC4IAmQyGRwdHdVqmtYjIiKiJ6NSCThz9R7CwhOQnF4g1o0MZBjYzRmD/V1gYcIppERNgdaB/PDhw3XZBxEREQFQqlSIikvD7ogEpGYWiXUTQz0M6u6MQd1dYGasr8MOiai28c4+REREDYBCqUL4xbvYE5GAeznFYt3MWB9De7hggJ8zjA35zzZRU/TYv9kFBQXIz8+Hubk5zMx4fVMiIqLHIVcocSI2FXsjE5CZVyrWLUwNMKyHK/p3bQVDA5kOOySiulajQK5UKvHTTz9h+/btSE5OFuvOzs6YOHEiXn75Zejp8d07ERHRo5TKlTh2PgV7oxORW1Am1q3NDTGipxt6ezvCQJ9BnKg50Do9l5WV4T//+Q9Onz4NiUQCR0dH2NvbIz09HSkpKfj8889x4sQJ/PTTT7xOORERUTWKSxU4cj4F+6ITkV8kF+t2lkYYGeiG4C6O0JNJddghEdU3rQP5+vXrER0djX79+mH+/Plwd3cXlyUmJmLFihU4cuQI1q9fj2nTptVFr0RERI1WUYkcB88k48CZJBSWVNz52sHGBKMC3RDQ0YFBnKiZkghaXqcwJCQEAPDXX39BKq36B0OlUmHMmDEAgNDQ0Fpsse6lp+c/eqVaZmVlgpycokevSI0ax7l54Dg3fU8yxvlFZThwJgmHziajuFQp1lvZmWJUkDv827eAVCqprVbpCfB3uXnQ1Tjb21e9f085rd+KJyYmok+fPhrDOABIpVL06dMHiYmJNWpu//79mDJlCrp16wYvL68qy2NiYjB+/Hh06dIFI0aMwLFjx9SWFxYWYv78+fDz80NAQABWrFgBpVJZZTtERET1KbegFL8dvoH3votAWHiCGMZdHcwwY1wXLH6lBwI6OjCME5H2U1b09fVRVPTwdxPFxcU1PqmzuLgYPXv2RFBQEFatWqW2LDs7G6+++ipGjx6NlStX4tChQ5g5cyZCQ0PFKTNLlizBxYsXsX79ehQWFmLu3LkwMzPDzJkza9QHERFRbcjKK8HeqEQcj7kDuUIl1ts4WSAkyB3eHraQSBjCiaiC1unZy8sL+/btw6xZs2BjY1NleVZWFvbt24f27dvXqIHyaS5RUVFVloWGhsLMzAwLFy6ERCJB27Ztcfz4cWzbtg3z5s1Dbm4uQkNDsW7dOnh7ewMA5syZg1WrVmH69OnVHs0nIiKqbek5xdgbmYCT/6RCoayYDerpYoWQYHd0dLNmECcijbQO5M8//zzefvttPPXUU3jjjTfQs2dP8Sor0dHR+O6775CVlYWFCxfWWnOxsbEICAhQ+wMWGBiI8PBwAMClS5cgkUjg7++vtjwzMxPJyclwdXWttV6IiIg0ScsqQlhEPCIupkFV6bSsTu7WGBXkDi9Xax12R0SNgdaBfMSIEbhy5QrWrl2L//3vf1WWC4KA//znPxgxYkStNZeVlYUOHTqo1aytrZGZmQkAyMzMhKWlJWSyiuu0lh+9z8zM1DqQW1mZ1FLH2pPJpDrZL9UvjnPzwHFu+jSNcWJaPnYcuY5TMXegqnR5hG7tW+CpAe0YxBsh/i43Dw1xnGs04fvtt9/GgAED8PvvvyMuLg4FBQUwMzNDx44dMWHCBHTt2rVWm3vUBWA0LX+cjwN1caYtz+RuHjjOzQPHuemrPMaJafkIDY/H2avpaut087THqCB3uLW8fyUF/kw0Pvxdbh4a4lVWanxbTV9fX/j6+j5JP1qztbVFVlaWWi07Oxu2trYAADs7O+Tm5kKpVIpHycuPnpevQ0REVBtu3clDWHg8LtzIEGsSCdCjgwNGBrrB2d5Mh90RUWPWoO9z7+3tjfXr16vVIiMj4ePjAwDo2LEjBEHAmTNnEBAQIC63tbWFs7NzfbdLRERN0LWkHPy94x9cuF5xRFwqkSCwkwNGBrmjpU3D+uibiBofrS9DsnfvXrz44otIS0vTuDwtLQ1TpkzB/v37a9RATk4OLl++LF6//PLly7h8+TLKysoQEhKCgoICLFu2DDdv3sTatWsRExODZ555BgBgZWWFUaNGYenSpYiNjUVkZCS++OILPPfcc7zCChERPTZBEBAXn4VPfjmHFb+cE8O4TCpBX18nLH+tJ14Z1ZFhnIhqhdZHyH///Xfk5+fDwcFB43IHBwcUFBRg+/btGDJkiNYNHD58GO+//774/dixYwEAhw4dgrOzM9auXYslS5Zg69atcHFxwerVq8VrkAPAokWLsGTJEkyZMgX6+voYN24c3njjDa33T0REVE4QBPxzKxOh4fG4mZIn1vX1pOjj7YThPV1hY2Gkww6JqCmSCI86c/JfvXr1Qv/+/fHRRx9Vu86iRYtw5MgRHD9+vNYarA/p6fn1vk+eONI8cJybB45z46cSBFy4noHQ8Hgk3K34N8FAX4r+XVth4iAvSFWqh2yBmgL+LjcPjfqkztzcXI03BKrMysoK2dnZ2ndGRESkQyqVgDNX7yEsPB7J6YVi3chAhoHdnDHY3wUWJgawsjBiUCOiOqN1ILe2tkZCQsJD10lISICFhcUTN0VERFSXlCoVIi+lYXdEAu5mVQRtE0M9DPZ3waDuzjA10tdhh0TUnGgdyP38/HD48GHcvHkTHh4eVZbfvHkThw4dQv/+/Wu1QSIiotqiUKoQfvEudkfEIz2nRKybGetjaA8XDPBzhrFhg74AGRE1QVr/1Xn55Zdx4MABPPfcc5gxYwZ69+4NBwcHpKWl4fjx4/j222+hUqnwyiuv1GW/RERENSZXKHE8JhV7oxKQlVcq1i1NDTAswBX9fFvB0ED2kC0QEdUdrU/qBIDffvsNS5YsgVKprLJMJpNh0aJFmDhxYq02WB94UifVFY5z88BxbrhKy5Q4diEFe6MTkVtQJtZtLAwxPMANfXwcoa/36CDOMW4eOM7NQ6M+qRMAnn76aXTr1g1btmxBTEwM8vPzYW5uDl9fXzz77LMap7IQERHVt+JSBQ6fS8b+00nIL5KLdXsrI4wMdEdQ55bQk/F+FUTUMNR4opyHhwc++OCDuuiFiIjoiRSWyHHwTDIOnklCYYlCrLe0McHIQDf07OQAGW8cR0QNDM9cISKiRi+/qAz7Tyfh8LlkFJdWTKtsZW+KkCB3dPdqAalUosMOiYiqV+NAfvjwYYSGhuLmzZsoLi7GgQMHANy/ysrhw4cxevToau/mSUREVJtyC0rxd3QijpxPQZm84sY9bg7mGBXkjq6edpBKGMSJqGHTOpALgoD58+dj165dAAAjIyOUlFRcMsrCwgKff/45BEHAtGnTar9TIiKif2XllWBvVCKOx9yBXFERxD2cLBAS7I4ubWwhYRAnokZC64l0W7ZswV9//YXx48cjOjoaL7/8stpye3t7+Pn54dixY7XeJBEREQCk5xRjw99XMO/7CBw6myyGcS8XK7w7yRcLJneDt4cdwzgRNSpaHyH//fff0b59eyxduhQSiUTjHzs3NzecPHmyVhskIiK6m1WE3RHxiLiYBlWlq/V2am2DkCB3eLpY6a45IqInpHUgv337Np555pmHHnWwtbVFVlZWrTRGRESUnF6A3REJiL6chsp3zfDxsMWoYHd4OFnqrjkiolqidSCXyWQoLS196DppaWkwMTF54qaIiKh5S7ibj7DweJy9lq5W7+Zlj1GB7nBrWf0NNoiIGhutA3nbtm0RHR0NQRA0HiUvLS1FZGQkOnbsWKsNEhFR83HzTi7CTsUj5mamWJNIgB4dHDAq0A2t7M102B0RUd3Q+qTO0aNH49atW1i+fDlUKpXaMqVSiY8//hj37t3DuHHjar1JIiJq2q4l5eCzX89j2cazYhiXSiQI7tISy17tiddGd2IYJ6ImS+sj5JMmTcLhw4exadMm/P333zA1NQUAvPnmm7hw4QLu3buHgQMHYvTo0XXWLBERNR2CICAuIRuhp+JxLSlHrMukEvTydsSInm6wtzLWXYNERPWkRnPI16xZg++++w6//PIL4uPjAQD79++HhYUFpk+fjunTp9dVn0RE1EQIgoDYm5kIC4/HzTt5Yl1fT4o+Pk4YHuAKGwsjHXZIRFS/JIJQ+bx17QiCgNu3byMnJwfm5uZo06YNZDJZXfRXL9LT8+t9n1ZWJsjJKar3/VL94jg3Dxxn7agEAeevZSAsPB4JaRV/dw30pRjQ1RlDe7jA0sxQhx1Wj2PcPHCcmwddjbO9ffUno2t9hLwyiUSCNm3aPHZDRETUfKhUAk5fuYewiHikpBeKdSMDGQZ2c8YQfxeYmxjosEMiIt3SOpArlUqUlZXB2Fh9Pl9ERAQOHToEY2NjPP3003Bxcan1JomIqPFRqlSIvJSGsIgEpGVVHI0yNdLD4O4uGNjdGaZG+jrskIioYdA6kH/yySfYunUrwsPDYW5+/5D77t278e6776J81sv27dvx559/wtHRsW66JSKiBk+hVOHUP6nYHZGAjNwSsW5uoo+hPVzRv2srGBs+1ge0RERNktZ/Ec+cOYOAgAAxjAPA6tWrYWFhgQULFiAjIwOrVq3Czz//jAULFtRJs0RE1HDJFUocj0nFnsgEZOdX3EjO0swAw3u4oq9vKxgaNN7zjYiI6orWgTw1NRVdu3YVv09KSsLt27cxY8YMjBkzBgBw+vRpnDhxova7JCKiBqu0TImjF1Lwd1QicgvLxLqNhSFG9HRDb29H6OsxiBMRVUfrQF5QUAAzs4qbMpw9exYSiQS9e/cWa+3atUNUVFTtdkhERA1ScakCh88lY190EgqK5WLd3soIIwPdEdS5JfRkWt9/joio2dI6kNvb2yM5OVn8PiIiAkZGRujUqZNYKyoqgp4e5wUSETVlhSVyHDyTjINnklBYohDrLW1MMCrIDQEdHSCTMogTEWlL6/Ts6+uLw4cP48iRIzA0NMS+ffvQs2dP6OtXnCGflJQEBweHWm0wLy8PK1aswLFjx1BUVAQvLy+888478Pf3BwDExMRg8eLFuH79OlxcXDBv3jz07du3VnsgIiIgr6gMB04n4dDZZJSUKcW6s70pRgW5o7tXC0ilEh12SETUOGkdyF977TUcOnRIvBunVCrFG2+8IS4vKChAdHQ0RowYUasNfvzxx4iLi8O3334La2trbNq0Ca+99hqOHTsGhUKBV199FaNHj8bKlStx6NAhzJw5E6GhoXB3d6/VPoiImqucglL8HZWIoxdSUCZXiXU3B3OEBLvDt50dpBIGcSKix6V1IPfy8sJvv/2GnTt3AgCGDx8Ob29vcfmVK1cQHByMUaNG1WqDsbGxePbZZ+Hj4wMAmD17NjZu3Ij4+HicP38eZmZmWLhwISQSCdq2bYvjx49j27ZtmDdvXq32QUTU3GTllWBvZCKOxdyBQlkRxD1aWSAkqDW6tLGBhEGciOiJ1WjCt5eXV7VBt3v37ujevXutNFWZr68vDhw4gJEjR8LCwgI7duxAy5Yt0bZtW2zYsAEBAQFq/yAEBgYiPDy8RvuwsjKp7bYfSSaT6mS/VL84zs1DUxvnu5mF+PPYTRw5mwSFUhDrndvYYuKAdujsYdvsgnhTG2PSjOPcPDTEcW7wZ2B+8MEHePfdd9GzZ0/IZDLY2Njgxx9/hLGxMbKystChQwe19a2trZGZmVmjfeTkFD16pVpmZWWik/1S/eI4Nw9NZZxTMwuxJyIBEZfSoBIqgnin1jYICXKHp4sVACA3t1hHHepOUxljejiOc/Ogq3G2tzevdlmDD+QbNmxASkoK1q9fD0tLS+zcuRPTp0/Hn3/+Kd4hlIiIHl9yegHCwuNx+vI9VP6r6tvWDqOC3NHGyUJnvRERNQcNOpCXlJTg66+/xsaNG+Hn5wcA6NixI44dO4bdu3fD1tYWWVlZao/Jzs6Gra2tLtolImpUEu7mIzQ8HueupavVu3nZIyTIHa4O1R/NISKi2tOgA7lCoYBcLodMpn6HN4lEAkEQ4O3tjfXr16sti4yMFE8AJSKiqm6m5CI0PB6xNyum90kkQEAHB4wMdEMre7OHPJqIiGpbgw7kZmZm8PPzw/Lly7Fw4UJYWlpix44dSElJQVBQEKysrLB69WosW7YMkyZNwqFDhxATE4OlS5fqunUiogbnamI2QsPjERefLdZkUgkCO7XEyEA3ONg0rJOciIiaiwYdyAHgiy++wCeffILXX38dxcXF8PDwwDfffIPWrVsDANauXYslS5Zg69atcHFxwerVq3kNciKifwmCgLj4bISeuo1rybliXU8mQa8ujhjR0w12VsY67JCIiCQCz4xEenp+ve+TZ3I3Dxzn5qEhjrMgCIi5mYmw8HjcupMn1vX1pOjr44RhAa6wsTDSYYeNS0McY6p9HOfmoclcZaWoqAj5+flQKpUalzs5OT3OZomI6AmpBAHnr6UjNDweiWkFYt1QX4b+fq0w1N8FlmaGOuyQiIgeVKNAvnPnTvz444+4efNmtetIJBLExcU9cWNERKQ9lUpA9JU07A5PQEpGoVg3NpRhYDdnDO7uAnMTAx12SERE1dE6kP/xxx9YsGABZDIZunfvjpYtW0JPr8FPQSciatIUShWi4tIQFpGAtKyKj2BNjfQw2N8Fg7o5w8RIX4cdEhHRo2idqNetWwdLS0ts2bIFHh4eddkTERE9glyhwqmLqdgTkYCM3BKxbm6ij6E9XNG/aysYG/KgCRFRY6D1X+uEhASMGzeOYZyISIfK5EqciE3FnsgEZOeXinVLMwMMD3BDX18nGOrLHrIFIiJqaLQO5JaWljAw4PxDIiJdKClT4Oj5O9gXnYjcwjKxbmthiBE93dDL2xH6egziRESNkdaBvH///oiOjoYgCJBIJHXZExER/au4VIFDZ5Ox/3QSCorlYt3eyggjA90R1Lkl9GRSHXZIRERPSutA/vbbb+PZZ5/FokWLMG/ePJiamtZlX0REzVpBsRwHzyTh4JlkFJUqxLqjrQlGBbqjR8cWkEkZxImImgKtA/ns2bNhbGyM7du3IzQ0FO7u7jA3r3qBc4lEgg0bNtRqk0REzUVeURn2Ryfh8LlklJRV3OvB2d4MIcHu6OZpD6mUn1ISETUlWgfy6Oho8evi4mJcvnxZ43qczkJEVHM5BaX4OyoRRy+koEyuEutuLc0xOsgdPu3sIOXfVyKiJknrQH7lypW67IOIqFnKyivBnsgEHI9JhUJZEcTbtrJESLA7Ore24YEOIqImjhepJSLSgXs5xdgTEY9T/9yFUiWI9fauVggJckd7N2sGcSKiZoKBnIioHqVmFmJ3RAIiL6VBJVQE8c6tbTAqyB2eLla6a46IiHSi2kB++vRpAIC3tzcMDQ3F77Xh7+//5J0RETUhyfcKEBYRj9OX70GoVPdta4dRQe5o42Shs96IiEi3qg3kkydPhkQiwZ49e9C6dWvxe21Ud8InEVFzE383D6Gn4nH+eoZYkwDo5mWPUUHucHWoerUqIiJqXqoN5DNmzIBEIoG1tbXa90RE9Gg3UnIRFh6P2JuZYk0iAQI6OmBkoDta2fFeDkREdJ9EEATh0as1benp+fW+TysrE+TkFNX7fql+cZybh8rjfDUxG7tOxeNyQra4XCaVILBzS4zs6QYHGxNdtUlPgL/LzQPHuXnQ1Tjb21f/iShP6iQiekKCIODi7UyEnYrHteRcsa4nk6CXtxNGBLjCzspYhx0SEVFDxkBORPSYBEFAzM1M7I1KxPWkHLGurydFX18nDA9wg7W5oe4aJCKiRoGBnIiohlSCgHNX0xEWHo/EewVi3VBfhv5+rTC0hyssTQ102CERETUmDORERFpSqQREX05DWEQC7mQUinUTQz0M6OaMIf4uMDPW12GHRETUGDGQExE9gkKpQuSlNOyOiEdadrFYNzXSwxB/F4wf4Al5qVyHHRIRUWPGQE5EVA25QoVT/6RiT2QCMnJLxLqFiT6G9nBFv66tYGyoB1NjfeQwkBMR0WNiICciekCZXInjMXewNyoR2fmlYt3KzADDA9zQx9cJhvoyHXZIRERNyWMH8tzcXBQVFcHR0bE2+yEi0pmSMgWOnr+Dv6MTkVdYJtZtLYwwItANvbq0hL4egzgREdWuGgXywsJCfP311wgNDUVWVhYkEgni4uIAADExMVi9ejXmzJmDTp061WqTly5dwsqVK3HhwgUYGBggKCgIX375pbjfxYsX4/r163BxccG8efPQt2/fWt0/ETVtRSUKHD6XjP2nk1BQXDH1pIWVMUYGuiGwc0voyaQ67JCIiJoyrQN5fn4+nnvuOVy/fh0dOnSAtbU1bt68KS739PTEmTNnEBYWVquB/ObNm5gyZQqmTp2K//73v5BKpeJ+s7Oz8eqrr2L06NFYuXIlDh06hJkzZyI0NBTu7u611gMRNU0FxXIcPJOEg2eSUVSqEOuOtiYYFeSOHh1aQCZlECciorqldSD/7rvvcP36daxYsQJjx47F6tWr8c0334jLjY2N0aNHD0RGRtZqg1988QWGDh2KmTNnijUPDw8AQGhoKMzMzLBw4UJIJBK0bdsWx48fx7Zt2zBv3rxa7YOImo68wjLsO52Iw+dSUFqmFOvO9mYICXZHNy97SCUSHXZIRETNidaB/MCBA+jVqxfGjh1b7TpOTk74559/aqMvAIBSqcSJEyfw6quvYvLkybh16xa8vLwwf/58eHp6IjY2FgEBAZBU+oczMDAQ4eHhtdYDETUd2fml2BediKPnU1CmUIl195bmCAl2h09bOwZxIiKqd1oH8rt372LIkCEPXcfExAT5+flP3FS5rKwsFBcX48cff8S8efPQpUsXbN68GS+99BL27duHrKwsdOjQQe0x1tbWyMzMrNF+rKxMaq1nbclkUp3sl+oXx7lhSM8pxp9Hb+DQmSTIKwVxLzdrTBzQDl097dXe2NcUx7np4xg3Dxzn5qEhjrPWgdzU1BRZWVkPXSc5ORnW1tZP3FQ5ler+P5zDhg3DpEmTAABLlixBnz59cPToUQiCUCv7yckpqpXt1ISVlYlO9kv1i+OsW/eyi7A7IgHhF+9Cqar4e9He1Qohwa3R3tUKEokEubnFD9nKo3Gcmz6OcfPAcW4edDXO9vbm1S7TOpB36dIFR44cQUFBAczMzKosv3fvHo4fP45+/fo9VpOaWFtbQyaToXXr1mJNX18fLi4uSE1Nha2tbZU3CdnZ2bC1ta21Hoio8UnNLERYeAKi4tKgqvTGvXMbG4QEuaOds5XumiMiInqA1oH8xRdfxKuvvopp06bho48+Ult28+ZN/Pe//0VpaSkmT55ca80ZGBigQ4cOSEhIEGsKhQIpKSlwcnKCoaEh1q9fr/aYyMhI+Pj41FoPRNR4JN8rQGh4PM5cuYfKn591bWeHUUHuaO1oobPeiIiIqqN1IO/duzdmzpyJ1atXY9SoUdDTu//QgIAA5OXlQRAEvPvuu/Dz86vVBqdOnYqFCxciICAAXbp0waZNmyCVStGvXz+UlZVh9erVWLZsGSZNmoRDhw4hJiYGS5curdUeiKhhi7+bh9BT8Th/PUOsSQB0a98CowLd4OpQ/ceEREREulajGwPNnDkT3bt3x6ZNmxATE4OcnBxIJBL07dsXU6ZMQWBgYK03GBISgszMTHz22WfIy8uDt7c3fv75Z5iamsLU1BRr167FkiVLsHXrVri4uGD16tW8BjlRM3EjJRehp+Lxz62KE7klEqBnRweMDHSHk52pDrsjIiLSjkSorTMjG7H09Nq7Moy2eOJI88Bxrn2CIOBqYg5Cw+NxOSFbrMukEgR2bomRgW5wsK7fs+c5zk0fx7h54Dg3D436pE4iIl0SBAGXbmchNDwe15NzxbqeTILe3k4Y3tMVdpbGOuyQiIjo8TxWIBcEAenp6VAoFBqXOzk5PVFTRETlBEFAzI1MhIbH43Zqnlg30JOir28rDAtwhbW5oQ47JCIiejI1CuR79+7FDz/8gGvXrkGpVGpcRyKRIC4urlaaI6LmSyUIOHc1HaHh8Ui6VyDWDfVlGODXCkN6uMLS1ECHHRIREdUOrQP5L7/8gqVLl0Imk8HPzw8ODg7ilVaIiGqLUqXC6cv3EBaRgDsZhWLd2FAPg7o5Y7C/C8yM9XXYIRERUe3SOlGvX78etra24tVMiIhqk0KpQsSlu9gdkYB72RV3zjQ10sMQfxcM7OYMEyMGcSIianq0DuRpaWl4+umnGcaJqFbJFSqc+icVeyITkJFbItYtTPQxNMAV/bu2gpEBP40jIqKmS+t/5RwdHVFWVlaXvRBRM1IqV+J4zB38HZWI7PxSsW5tbohhAa7o4+MEQ32ZDjskIiKqH1oH8nHjxuHXX39FQUEBzMzM6rInImrCSsoUOHI+BfuiEpFXJBfrthZGGBHohl5dHKGvJ9Vhh0RERPVL60D+6quv4tKlS3jppZcwd+5cdOzYkcGciLRWVKLAoXPJOHA6CQXFFUG8hbUxRga6IbBTS+jJGMSJiKj50TqQy2QyPPfcc5gzZw6mTJlS7Xq87CERVVZQLMeB00k4eDYZxaUV9y5wtDXBqCB39OjQAjIpgzgRETVfWgfygwcPYvbs2VAqlXB2dkaLFi0gk3F+JxFplldYhn3RiTh8PgWlZRX3LXBpYYaQIHf4edlDKpHosEMiIqKGQetAvnr1ahgZGWHNmjXo3r17XfZERI1Ydn4p/o5KxLELKShTqMR6a0dzhAS1hk9bW0gYxImIiERaB/Lbt29jzJgxDONEpFFGbjH2RibiROwdKJSCWG/rbInRQe7o1NqGQZyIiEgDrQO5tbU1DAx4m2oiUpeWXYTdEQmIuHgXSlVFEO/gZo2QIHd4uVoxiBMRET2E1oF8yJAhOHHiBORyOfT1ebc8oubuTkYhdkfEIzIuDUJFDkeXNrYICXJHW2dL3TVHRETUiGgdyOfMmYPY2FjMnj0bCxYsgLOzc132RUQNVNK9AoSGx+PslXuolMPRtZ0dRgW5o7Wjhc56IyIiaoy0DuQhISFQKBSIiYnBkSNHYGFhofE65BKJBAcPHqzVJolI926n5iEsPB7nr2eINQmA7u1bYFSQO1xa8L4EREREj0PrQC4IAmQyGRwdHdVqmtYjoqbjRnIudoXfxsVbWWJNKpEgoKMDRga6wcnOVIfdERERNX5aB/LDhw/XZR9E1IAIgoAriTkIPXUbVxJzxLpMKkFQ55YYGeiGFtYmumuQiIioCdE6kBNR0ycIAi7dzsKu8HjcSM4V63oyCXr7OGF4gCvsLI112CEREVHTw0BORBAEARduZCAsPB63U/PFuoGeFH19W2FYgCuszQ112CEREVHTVW0g37lzJwBg0KBBMDMzE7/XxtixY5+wLSKqDypBwNmr6Qg9FY/k9AKxbmggwwC/Vhjq7woLU95/gIiIqC5VG8jnz58PiUQCHx8fmJmZid8/jCAIkEgkDOREDZxSpUL05XsIC49HamaRWDc21MPg7s4Y1N0FZsa83wAREVF9qDaQL1++HBKJBPb29gCAjz/+uN6aIqK6oVCqEHHxLnZHJuBedrFYNzPWx2B/Fwz0c4aJEWeyERER1adq/+UdP348du7cieTkZLRv3x7jxo2rz76IqBbJFSqc/CcVeyISkJlXItYtTA0wrIcr+nV1gpEBgzgREZEuPPRf4Pfffx8zZsxA+/bt66sfIqpFpXIljl+4g71RCcgpKBPr1uaGGBbgir4+TjDQl+mwQyIiIpI+bGFDu8nPjBkz4OXlhaioKLEWExOD8ePHo0uXLhgxYgSOHTumww6JGobiUgX2RiZg3nfh2HrouhjG7SyN8OJQL6x4LRCDu7swjBMRETUAjeYz6p07d6K4uFitlp2djVdffRWjR4/GypUrcejQIcycOROhoaFwd3fXTaNEOlRUIsehs8nYfzoJhSUKse5gbYyRge7o2ckBerKHvg8nIiKietYoAnlaWhq+/PJL/PLLL+jfv79YDw0NhZmZGRYuXAiJRIK2bdvi+PHj2LZtG+bNm6fDjonqV0GxHPtPJ+HQ2SQUlyrFupOdKUYFusG/QwvIpAziREREDdEjA3l+fj7u3LlTo406OTk9dkOaLFy4EK+99lqV7cbGxiIgIEDtcoyBgYEIDw+v1f0TNVS5hWXYF52II+dSUCqvCOIuLcwQEuQOPy97SB9xuVIiIiLSrUcG8o0bN2Ljxo1ab1AikSAuLu6Jmqrs119/hUKhwKRJk6osy8rKQocOHdRq1tbWyMzMrNE+rKxMnqjHxyGTSXWyX6pfdTXOmbnF2Hn8Fg5EJ6BMrhLrbZ0tMXGAJ7p3aPHI+wZQ7eHvc9PHMW4eOM7NQ0Mc50cGcjMzM5ibm9dHL1XcuXMHq1evxq+//qpxeW2ddJqTU/TolWqZlZWJTvZL9au2xzkjtxh7IhNxMvYOFMqKn/92zpYICXZHJ3cbSCQS5OYWP2QrVNv4+9z0cYybB45z86Crcba3rz5PPzKQT5kyBTNnzqzVhrQVFxeHjIwMDBkyRK0+depUjBs3Dra2tsjKylJblp2dDVtb2/psk6jOpWUXYXdEAiIu3oVSVRHEO7hZY3SwO7xcrXXYHRERET2JBn1SZ8+ePbFr1y61WkhICJYuXYpevXph3759WL9+vdryyMhI+Pj41GOXRHXnTkYhwiLiERWXhsofCHl72GJUkDvatrLUXXNERERUKxp0IDczM4Onp2eVurOzMxwcHBASEoLVq1dj2bJlmDRpEg4dOoSYmBgsXbpUB90S1Z7EtHyEhcfj7NV0VJ6Y1bWdHUKC3eHe0kJnvREREVHtatCB/FGsra2xdu1aLFmyBFu3boWLiwtWr17Na5BTo3U7NQ+hp+Jx4UaGWJMA8O/QAiMD3eHSwkx3zREREVGdaHSB/OrVq2rf+/r64o8//tBRN0S143pyDkJPxePi7YpzIqQSCQI6OmBUkBscbU112B0RERHVpYcG8itXrtRXH0TNjiAIuJKQjdDweFxJzBHrMqkEwV1aYkRPN7SwbliXZSIiIqLa1+iOkBM1doIg4OLtLISeiseNlFyxrieToo+PI4YHuMHW0kiHHRIREVF9YiAnqieCIODC9QyEhscj/m6+WDfQk6Jf11YY2sMV1uaGOuyQiIiIdIGBnKiOqVQCzl5LR+ipeCSnF4h1QwMZBvo5Y4i/CyxMDXTYIREREekSAzlRHVGqVDh2Phm/HbyG1MyKO4IZG+phcHdnDOruAjNjfR12SERERA0BAzlRLVMoVQi/eBd7IhJwL6fiFvZmxvoY4u+CAX7OMDHirx4RERHdx1RAVEvkCiVOxqZiT2QCMvNKxbqFqQGG9XBFv65OMDLgrxwRERGpYzogekKlciWOXbiDv6MSkFNQJtatzQ0xvl9b+HvawUBfpsMOiYiIqCFjICd6TMWlChw5n4J90YnIL5KLdTtLI4wIdENwZ0fY25khJ6foIVshIiKi5o6BnKiGikrkOHg2GQdOJ6GwRCHWHayNMTLQHT07OUBPJtVhh0RERNSYMJATaSm/qAwHziTh0NlkFJcqxXorO1OMDHJDj/YOkEolOuyQiIiIGiMGcqJHyC0sw77oRBw5l4JSeUUQd21hhpBgd3T1tIdUwiBOREREj4eBnKga2fml2BuZgGMxdyBXqMR6a0cLhAS7w8fDFhIGcSIiInpCDORED8jIKcaeyASc/CcVCqUg1j2dLRES3Bod3a0ZxImIiKjWMJAT/Sstqwi7IxIQcekulKqKIN7R3RohQe7wcrXWYXdERETUVDGQU7OXklGI3eHxiLqcBqEih8PbwxajgtzRtpWl7pojIiKiJo+BnJqtxLR8hIbH49zVdFTK4fDztEdIkDvcWprrrDciIiJqPhjIqdm5dScPYeHxuHAjQ6xJAPh3aIFRge5wbmGmu+aIiIio2WEgp2bjWlIOQsPjcel2lliTSiTo2ckBIwPd4GhrqsPuiIiIqLliIKcmTRAEXEnIRmh4PK4k5oh1mVSC4C6OGBHohhZWxrprkIiIiJo9BnJqkgRBwD+3shAafhs3U/LEup5Mij4+jhge4AZbSyMddkhERER0HwM5NSkqQcCF6xkIDY9Hwt18sW6gL0U/31YYFuAKKzNDHXZIREREpI6BnJoElUrAmav3EBYej+T0QrFuZCDDwG7OGOzvAgsTAx12SERERKQZAzk1akqVClFxadgdkYDUzCKxbmKoh0HdnTGouwvMjPV12CERERHRwzGQU6OkUKoQfvEudkfEIz2nRKybGetjaA8XDPBzhrEhf7yJiIio4WNioUZFrlDiRGwq9kYmIDOvVKxbmBpgWA9X9O/aCoYGMh12SERERFQzDT6Qf/fdd/j777+RkJAACwsLDBkyBG+99RZMTSuuGR0TE4PFixfj+vXrcHFxwbx589C3b18ddk21rVSuxLHzKdgbnYjcgjKxbm1uiBE93dDb2xEG+gziRERE1Pg0+EB+/vx5/Oc//0GnTp2QmZmJDz74AIWFhfj4448BANnZ2Xj11VcxevRorFy5EocOHcLMmTMRGhoKd3d33TZPT6y4VIHD55Kx/3QS8ovkYt3O0ggjA90Q1NkR+npSHXZIRERE9GQafCBfu3at+HWbNm0we/ZsLFq0SKyFhobCzMwMCxcuhEQiQdu2bXH8+HFs27YN8+bN00XLVAuKSuQ4eCYZB84kobBEIdYdbEwwKtANAR0doCdjECciIqLGr8EH8gdlZ2fD3Nxc/D42NhYBAQGQSCRiLTAwEOHh4Vpv08rKpFZ71IZMJtXJfhu6vMIyhJ68hb3h8SgqrQjiLg7mmDigLQK7OEEmlTxkCw0Lx7l54Dg3fRzj5oHj3Dw0xHFuVIE8Pz8f69atw4QJE8RaVlYWOnTooLaetbU1MjMztd5uTk7Ro1eqZVZWJjrZb0OVW1CKfdFJOHI+BaVypVh3dTBDSJA7unraQyqRID+vWIdd1hzHuXngODd9HOPmgePcPOhqnO3tzatd1mgCeVlZGWbNmgUXFxdMmzZNrAuCoMOu6Ell5ZVgb1QijsfcgVyhEuttnCwQEuQObw9btU8/iIiIiJqaRhHIFQoF3nrrLRQWFmL9+vXQ06to29bWFllZWWrrZ2dnw9bWtr7bpBpIzynGnsgEnIxNhVJV8abK08UKIcHu6OhmzSBOREREzUKDD+QqlQrz5s1DYmIiNm3apHa5QwDw9vbG+vXr1WqRkZHw8fGpxy7pUaRSCWQyKdIyC/HniVuIuJgGVaVPNzq6WyMkyB1ertY67JKIiIio/jX4y1R88MEHiIqKwsqVKyGXy5Geno709HQolffnGYeEhKCgoADLli3DzZs3sXbtWsTExOCZZ57RcedUTiKTILtIjoNnk1GiAoyNDcQw7u1hi4WTu+HdSV0ZxomIiKhZavBHyH///XcAwNixY9Xqhw4dgrOzM6ytrbF27VosWbIEW7duhYuLC1avXs1rkDcQdzILoWeghwXfnoJKAKQSYMlrQVDKlejj4wS3ltWf4EBERETUHDT4QH716tVHruPr64s//vijHrqhRymfmnL7Th52HL0BJQCfdvYonyauEoD4O7l4eVRHyCtdTYWIiIiouWrwU1ao8ZDIJMgqkuPA2WRI9WWwtzXF3cxCdHC3Qfmlw6USwLudPZRK1cM3RkRERNRMNPgj5NTwCYKAm6l5MDczwsLv1KemGMqksDDWw+dv9cOlWxno7GEHcyMZVEperpKIiIgIYCCnxySVSiCVSnDpdiZ+P3ITxsb6VaamJKTmYtKgdpDLlZBKJejdxRFKpYphnIiIiKgSTlmhmpNKkFlwf2qKubkxWjtbaZya0qVtxdQUlUqAXK6ESsUwTkRERFQZj5CT1lQqARfjs9DC1gz//V59aoqNmQFszQw4NYWIiIiohhjI6aGkUgkkEuD05Xv4/ehN2Fkba5iakoeQ4NaQy5Uw5tQUIiIiohrhlBWqlkoCZBSU4cC5FLRsYY7Obe1wN7MQHatMTbHj1BQiIiKix8Qj5FSFXKHEmavpcHe2wgffh4tTUz56LQgudiawtzTi1BQiIiKiWsJATgDuT01RqYCTsSnYcfwWXBzMUSRXqd/QJzUPA7q5QC5XwtJIxqkpRERERLWAU1YICpWA9PwyHL6QgjauNvDv2PL+1JTWnJpCREREVNd4hLwZKyyRI/JSGjp62OGDNRVTU5a+Hoz2zpZoacWpKURERER1jYG8GZFKJZDJpMgtKMXeyAQcPpcMD2crQCZ9YGpKLnp3ceTUFCIiIqJ6wCkrTZxUKoG+vgxSmRQ5xQocOpeMnGIFSpUCikuVuJtZiE5tbNWmpnT24NQUIiIiovrCI+RNmEQmQW6xAteTc9C2lRXe/uKY2s18snOL0dvbkVNTiIiIiHSIgbwJkkol0NOTISO/FG9/cQwd29giO69UbVrK7ZRczJ7oA4VCBagETk0hIiIi0hEG8iaifH64UiUgu1COlHvZyCm4H8LvZhZi0mAvSCUQj5D7eNqrTUNRqQSoVEodPgMiIiKi5omBvAkQp6Yk5aCtsxXe+fIYbCyNMGeSH6QSICOnBMfOJWPVW30RdyuT01KIiIiIGhAG8kasfGpKel4p3vny36kp+fePimfklODouWSsnNUH1xKz0NnDDpYmepyWQkRERNTA8CorjUzlq6ZkFclx/kYGLt3KEKemdHCvuJnP4dOJMDaUoY+3IywMZVDKVbxiChEREVEDwyPkjUjlqSkezlZ498vjj5yaYmIgRVkZ54YTERERNVQM5I1A+Qmb6fmlePfL45yaQkRERPQYpP9OI5BKJQ1qxgADeQNVHsIVKhUyC+RISc9HXkGZxqumHD6diHF9PdDH2xEKhQpKuQo8Jk5EREQNgSAIgCAAUAEqFYB/vxcEQFABggBBUIlfV67fX1f17/IHlolf/7sNCA9sX32bFq1coG9kAsgBC/1SyAUZCstkun1x/sVA3gCVT025lpiNti7WmPsVp6YQEVHzJYjB7MFA9kAYq2ZZ+ffVB8P765UWGECRX1xNMLx/3w4BmoKh+v+FB8Lkg+sImh7/QJgUqtm22jYeEnDVQqzG10bTPiqeJ/DgOg95vmq9a9qm7o9Ey8xtoP/s/5C6aSEs/IYi79w+OE1dAalUr0EcKWcgb0DKj4rfyyvF3K/uT03J+feoOKemEBE9mSc5SqcQDKHKK6qVo3QagxY09VFduFFBqBSYNIZHMfRVCmQaApPGYPhAiKu+l8pBWIvwqCF0PjQYVg7CQv38G1dUL3shXVDmZ6Hg0glY+A1B9rGtsB44BaUSI6hUKl23BoCBvMFQSYCsgjLcySjg1BSiBkxTIFOVSiCUFlYKJ092lE6o5nE8Sqe7o3SFT/ZjQ/RoEgkA6f3/S8r/X/G1RPLAMkgAqfT+/yVSSNQeV/XxkEghUXtM1fUl1WxbfR1N+1HfZrXrlPcEKSTSJ3u+6uuU1x7otVJPUn0DmLWwQ+rGBbAZOBW50bvg1DEYpVJDHiGvTWvWrMGmTZuQn5+P4OBgfPTRR7C1tdV1WxqVn1BgYKCHMrkC0XFpcHGyxBdbz0EAMPeF7nCwNkJadgnOXU7Dl+/0wz83MuDTzh5mhjKUlSkhlUrEExLKt1eTrx/84au8rcrL6rreHD3WUboHggaP0jWso3QFdf5TQ6QlTQHl3yBTEU40hxf1QPa4Qal8uaYQVr7eg4Gtak+1EQyr9Knp+UJ6//bV/z5fM3NjFBSWqfUjeTDYVnoeVft4dDCs9nWnOqeQKOE0dQUkRuYw7RgEuSBrMJlEIgj19DlQHdqxYweWLl2KlStXwtnZGcuXL4dUKsWGDRu0enx6en4dd1jB1EAJfen9ICbI9CFRynEvuwiCAJibGuDQ2TsYGeQGKQQk3M2Dm6MlIAgoyc2GkZXN/a/LlDAy1AMgoKREASMj/ftfl6r+rav+/Vp2v16sgJFxxTqG+hIo5ArkZWUDKhUsbK2hZ2CA0uIyGBobQFFWhryMTFjY2d6vl5TB0OjfeloazFu0gL6hAUqKimFkYgx5SQny7iTBwtEZ+kbGKM7Pg7G5OeRFhciNvwZLt7bQNzVHcVY6jG3sIS/IRc712IeHsSZylE4CAYJKQ7gmarCqO7pWfuRLcwjTGKYeNxhCAkk121Y/AvfAtjWGy5oGQ81HDE1MjVBULH/g9akuGFZ6jaoEQ82v7f1gqPl5qL3ujwqG9ESsrEyQk8OJK02ZVCqBhYUx8vKK6z2M29ubV7usSRwh37x5M1566SUMHjwYALB8+XIMGjQI165dg6enp467qyCVSqAvFSCUFiF1y2LxpALHF5YAKiVSt3yAAT3HQCJvgTtbFsOu51gItj5I3bIYlj3HQjCp9HWbx/vawm8oss7tg+Oz/0Ppvs8BAHrP/g+pGxfAwm8Iss7th+Oz/4MicjP0QmZVrZ/+Ffohs5C6cSEs/IYg9d+68sJf0HeZ9e/JEhV11dXD0PfshNRN/71f3/3l/e1c3AdlfpaOR6TuNdvorRYaHgwajw4oEjw8vDw6GD4YxjQdaasc6qoPVNoEQyNjQ5SUKh47GEoecjRS2yOGVY7iPU4wBENddUytTCBnUCNq9MpDeEM5Ml6u0R8hLysrg4+PDzZs2IAePXqI9QEDBuCNN97AxIkTH7mN+jpCLpVKIJMoYJCbgNKUa8g+9ius+78AoawYACDR00f2sV/R8rn/oTT1FrKPbK6Tr637ToKgkCPn1A4AgFXwBHHflZfVdf3hNIcwMXw8Yh6c5o8ZaxgM8ZCPRB98fDWBysjIAKVlyicOhpqfb02PGD5kjuG/H9vWWjBsZnhUrenjGDcPHOfmQVfj3KSPkGdnZ0OlUlWZL25jY4OsLO2OwFpZmdRFa1VIJIC8IBcyc1ukn9sP677PIu/MHji++DEkUOHOxoWwGfoq9MxtkR66GjbDpolf2w5/rVL91Rp+XbEd6wGTkXd6N5xeXAa9lu0AiRTGDi64s3EhrAe8iLzTYXB6cRkM3LxhaN3igfpyGLbuCgNLO9zZuKCiPmU5jLwCoW9ihjsbFsBmwIvIPR0Gpykfw9h7IPT0ZLiz/n3YDJyC3OhQOE1dAdPuIf++KA8G0qb10atMJoVS2TDO4Ka6I5NJ6+3vCOkGx7h54Dg3Dw1xnBv9EfK0tDT06dMHe/bsgYeHh1h/6qmnMHjwYLz22muP3EZ9HiE3kMphIFVBAgAyPUhUCigggyAA+hIlSiVGMEQpIAh197VQonYxfFMDZcW+Ky2r63pzwKMtzQPHuenjGDcPHOfmgUfI64C1tTWkUikyMzPVAnlWVhZsbGx02FlVKpWAUok+sopUSLibBy83axjI9KH494Y+9y9Or0Kp1ODf9evqa/VL/BSWySrtu2JZXdeJiIiICJDquoEnZWBggPbt2yMqKkqsJSUlISUlBT4+PjrsTDNBKcDMQIqgLo7QEwQxjAPqJxrU9dcPqm5ZXdeJiIiImrtGf4QcAJ5//nksX74cHTp0EC97GBAQ0KCusFKZSiVAEBhOiYiIiKiJBPKnnnoKmZmZ+PDDD5Gfn4+goCB89NFHum6LiIiIiOiRGv1JnbWhPm8MVI4njjQPHOfmgePc9HGMmweOc/PQEE/qbPRzyImIiIiIGjMGciIiIiIiHWIgJyIiIiLSIQZyIiIiIiIdYiAnIiIiItIhBnIiIiIiIh1iICciIiIi0iEGciIiIiIiHeKNgYiIiIiIdIhHyImIiIiIdIiBnIiIiIhIhxjIiYiIiIh0iIGciIiIiEiHGMiJiIiIiHSIgZyIiIiISIcYyImIiIiIdIiBnIiIiIhIhxjIiYiIiIh0iIFcB9asWYNevXrBx8cH06dPR2Zmpq5bomp89913GDNmDHx9fdGnTx8sXboUhYWFauvExMRg/Pjx6NKlC0aMGIFjx46pLS8sLMT8+fPh5+eHgIAArFixAkqlUm2dHTt2YMCAAfD29sbkyZORkJBQ58+NNJsxYwa8vLwQFRUl1jjGTcelS5cwZcoU+Pj4wN/fH7NnzxaXcZybhry8PCxYsADBwcHo2rUrJk2ahNOnT4vLOc6Nz/79+zFlyhR069YNXl5eVZbXx5jevn0bkydPhre3NwYMGIA//vijdp+kQPXq999/F3x9fYX9+/cLcXFxwgsvvCC8+OKLum6LqvHqq68Ku3btEm7evClER0cLQ4cOFebPny8uz8rKEvz9/YWPPvpIuH79uvD9998LnTt3Fm7fvi2u89577wkjRowQYmJihPDwcCE4OFj4+uuvxeXh4eFCp06dhN9++024evWqMHv2bGHIkCGCXC6vz6dKgiD8+eefwksvvSR4enoKkZGRgiBwjJuSGzduCN26dRO+/vpr4dq1a8KNGzeEffv2CYLAcW5K5s+fL4wePVq4cOGCkJCQICxdulTo2rWrkJeXx3FupHbu3Cl8++23wvfffy94enqqLauPMS0rKxMGDx4szJ49W7h69arw22+/CZ06dRKioqJq7TkykNezsWPHCl9++aX4fWJiouDp6SlcvXpVh12Rtvbs2SP4+/uL32/YsEHo37+/oFKpxNpzzz0nrFixQhAEQcjJyRE6dOggREREiMu3b98uBAYGCkqlUhAEQZgxY4bw3nvvicsLCwsFb29v4fDhw3X9dKiSu3fvCv369RNSUlLUAjnHuOmYOXOmsGDBAo3LOM5Nx4gRI4RNmzaJ3+fn5wuenp5CbGwsx7mRi4yMrBLI62NMDx48KHh7ewuFhYXiOnPnzhVmzZpVa8+NU1bqUVlZGa5cuYKePXuKNRcXF7Rq1QoxMTE67Iy0lZ2dDXNzc/H72NhYBAQEQCKRiLXAwEBxPC9dugSJRAJ/f3+15ZmZmUhOTha3UflnwsTEBN7e3vyZqGcLFy7Ea6+9BicnJ7U6x7hpUCqVOHHiBJycnDB58mQEBwfj5ZdfxrVr1wBwnJsSX19fHDhwANnZ2VAqldixYwdatmyJtm3bcpyboPoY09jYWHh7e8PExETjPmoDA3k9ys7Ohkqlgq2trVrdxsYGWVlZOuqKtJWfn49169ZhwoQJYi0rKws2NjZq61lbW4vnBWRmZsLS0hIymUxcXr5++TqatsGfifr166+/QqFQYNKkSVWWcYybhqysLBQXF+PHH3/EyJEjsXbtWjg4OOCll15CQUEBx7kJ+eCDD2Bubo6ePXuiS5cu+OGHH7BmzRoYGxtznJug+hjTrKwsjdmtNs8B1Ku1LRE1YWVlZZg1axZcXFwwbdo0sS4IwkMfp2l55XfxpHt37tzB6tWr8euvv2pczjFuGlQqFQBg2LBh4huvJUuWoE+fPjh69CjHuQnZsGEDUlJSsH79elhaWmLnzp2YPn06/vzzT45zE1QfY/qofdQGBvJ6ZG1tDalUiszMTHh4eIh1Te/MqOFQKBR46623UFhYiPXr10NPr+LXxtbWtspRkezsbPGdtJ2dHXJzc6FUKsV35+XvqMvX0XRkJSsrC61bt66z50QV4uLikJGRgSFDhqjVp06dinHjxnGMmwhra2vIZDK111xfXx8uLi5ITU3lODcRJSUl+Prrr7Fx40b4+fkBADp27Ihjx45h9+7dHOcmqD7G1NbWtspVVzQdNX8SnLJSjwwMDNC+fXu1y6klJSUhJSUFPj4+OuyMqqNSqTBv3jwkJibihx9+gKmpqdpyb29vtfEEgMjISHE8O3bsCEEQcObMGbXltra2cHZ21riN4uJixMbG8meinvTs2RO7du3Czp07xf8AYOnSpZg9ezbHuIkwMDBAhw4d1P5RVSgUSElJgZOTE8e5iVAoFJDL5WrTE4D7R0QFQeA4N0H1Mabe3t6IjY1FcXGxxn3Uilo7PZS0sn37dqFr167CgQMHhMuXLwuTJ08WJk+erOu2qBoLFiwQgoODhbi4OOHevXvifwqFQhCEisstLV26VLhx44awZs2aKpdbmjt3rjBq1CghJiZGiIiIEHr16qXxckvbt28Xrl27JsyZM0cYMmSIUFZWVt9Pl/6l6bKHHOPGb9euXUKXLl2Ev/76S7h165awePFioVevXkJBQQHHuQmZNGmS8PTTTwsxMTFCfHy88NlnnwmdO3cWbt26xXFupLKzs4W4uDjht99+Ezw9PYW4uDghLi5OKC0trZcxLS0tFQYNGiS89dZbwrVr14Tt27fzsodNwffffy8EBwcL3t7ewuuvvy6kp6fruiWqhqenp8b/kpKSxHXOnz8vjBs3TujUqZMwbNgw4ejRo2rbKCj4//buP6aq+o/j+JNf/ogLEbUgsaKJQ+xqYCCQglCNXDJLC6eNOXPliGHGao1KwmaLWs1+cFfR/DGhdGI4thYZlIwrEd3ijpH2Q6HpIoU/lPjRrQVxvn847rjem94SuHy/39dju9vd53PO53zOORu8du77fu6g8fTTTxvx8fFGUlKS8dJLLzkD/aiDBw8amZmZhtlsNnJzc13+kMjkGxvIDUP3+H/Jnj17jPT0dCM+Pt5Yv369cfLkSWef7vP/hu7ubqOwsNBITU014uPjjQceeMBobGx09us+//eprq6+5P/iybinnZ2dRm5urmE2m43MzEyjurp6XM/RzzAmoVJdREREREQ8Ug25iIiIiIgPKZCLiIiIiPiQArmIiIiIiA8pkIuIiIiI+JACuYiIiIiIDymQi4iIiIj4kAK5iIh41NXVRWxsLEVFRT45/ldffUVsbCxlZWU+Ob6IyGQJ9PUERET+X8TGxrq1BQUFcf3115OUlMSmTZuYM2fOuBxn8eLFVFZWXvFY4+2TTz7hww8/5LvvvqO/vx+TycS1117L/PnzWbJkCatWrfL1FEVEJp0CuYjIJCsoKHC+HxgYoL29nZqaGurq6ti3bx9xcXE+nN3EKS4upqqqihkzZrBs2TJmz57N77//zs8//0xDQwM2m80lkC9cuJDa2lquueYaH85aRGTiKZCLiEyyzZs3u7Vt376d999/n7179/Lyyy/7YFYTq7W1laqqKiIjIzlw4ACRkZEu/UNDQ9hsNpe2mTNnjssnBiIiU51qyEVEpoAlS5YAcP78eZf2gYEBdu7cyfr160lPT8dsNpOSkkJeXh5tbW0u2x46dMhZFmOz2YiNjXW+Lq7Dbm9v54knniAtLQ2z2czSpUvZuHEjtbW1HufX1dVFYWEhycnJLFiwgNWrV9PQ0OD1+dntdgCysrLcwjhcKN0ZvQajPNWQl5WVuZyXp9fFjh49yqOPPkpycjJms5m7776bV155hf7+fq/nLyIykfSEXERkCmhubgbAbDa7tHd2dvLGG2+QmJhIRkYGoaGhnD17liNHjnD06FHeeecd0tPTAYiLi6OgoACLxUJUVJRL+cfixYud76uqqti2bRv+/v7ceeedREdHc+7cOY4dO8b+/fu59957Xebwyy+/kJOTw4033sh9991HX18ftbW15Ofns2fPHlJSUi57fmFhYQCcOnXq31wel/MYW/Iz6uzZs1RXVzNjxgyXdovFQllZGWFhYWRkZBAeHs6JEyfYvXs3VquVAwcOYDKZrmhOIiJXSoFcRGSSjX3iOzg4yLfffovdbiczM5ONGze6bDtnzhysVivh4eEu7d3d3Tz44IOUlpa6BPK4uDhnIPdUGtPR0cELL7yAyWTigw8+YO7cuW7jXsxms7F582aXIJydnc0jjzzCrl27vArk6enphISEYLVaycvLY8WKFSxYsICbb74ZPz+/y+4/Kjk5meTkZJe2wcFB1q1bh7+/P6+++qqzvaWlhbKyMhISEnjvvfcIDQ119h06dIhnnnmGt956i2effdbr44uITAQFchGRSWaxWNzaYmJiWLFihdvT2pCQEI9jREZGsnz5ciorKzlz5gyzZs3y6tj79+9neHiY/Px8tzA+Ou7FoqKieOyxx1za0tLSmDVrFu3t7V4dNyIiAovFQnFxMQ0NDc5yl+DgYBISEli5ciXZ2dkEBAR4Nd6o4eFhtmzZwokTJygqKiIrK8vZN7rKzPbt213COMDq1aupqKjgo48+UiAXEZ9TIBcRmWQ//vij873D4aCjo4PXXnuNp556io6ODgoLC122b21tpaKigra2Ns6dO8fQ0JBLf09Pj9eBfLTuPC0tzev5zps3z2NQjoyMdKtjv5SUlBQ+/fRT7HY7NpuN77//HrvdTlNTE01NTdTU1FBeXs60adO8HnPbtm00NTXx0EMP8fDDD7v0tbW1ERQUxOHDhzl8+LDbvkNDQ5w/f57e3l6t5CIiPqVALiLiQ1dddRULFy7EYrGwbNkydu7cydq1a7nhhhsAqK+v5/HHH2f69Onccccd3HTTTcycORN/f39sNhs2m40///zT6+MNDAwAF55Ye+vip8ujAgMDGRkZ8XocAH9/fxITE0lMTATAMAy++OILioqKaG5uZt++fWzYsMGrscrLyzl48CAZGRls3brVrf/XX39leHjY4ycSYzkcDgVyEfEpBXIRkSkgNDSUW265hePHj3P8+HFnIH/zzTcJCgqiurrabQnA559/3m2pwMsZLYHp6emZEl9m9PPzY+nSpWzZsoWtW7fS0tLiVSCvra3l9ddfZ/78+ezYscPjE3yTyYRhGP/4GomITDYteygiMkX09fUBF54ajzp9+jQxMTFuYXxkZITW1laP4/j7+/PXX3957IuPjwcuLAU4lQQHB3u9rd1up6ioiIiICN59992/3Tc+Pp6+vj5Onjw5XtMUEZkQCuQiIlPAZ599RldXF0FBQSQkJDjbo6KiOHXqFD09Pc42wzCwWCx0dHR4HCssLMzjaikA69atIzAwkLffftvj/n+335WyWq3U1dW51b8D/Pbbb1RUVAA4S1n+zunTp8nPzycwMJDy8vJLlt6MPmkvLi52uX6jHA7HP6qBFxGZKCpZERGZZGOXPXQ4HHR2dmK1WgEoLCzkuuuuc/Zv2LCBkpISVq1aRVZWFoGBgdjtdjo7O8nMzPT44zypqal8/PHH5OXlceuttxIQEEBSUhJJSUnExMRQUlJCSUkJ999/P3fddRfR0dH09vZy7NgxgoODnauTjKeffvqJ0tJSrr76am6//Xaio6MJCAigu7ubxsZG+vv7ue2228jNzb3kOC+++CK9vb2kpKRQX19PfX292zajyz2mpqby5JNPsmPHDu655x7S09OZPXs2DoeDM2fO8PXXX7No0SJ27do17ucrIvJPKJCLiEyysV8yDAgIIDw8nMzMTHJzc91+rXLt2rVMmzaNvXv3UlNTw/Tp00lMTKS0tJS6ujqPgfy5557Dz8+PL7/8ksbGRkZGRigoKCApKQmANWvWMHfuXHbv3o3NZuPzzz8nLCyM2NhYcnJyJuScV65ciclkorm5mR9++IFvvvkGh8NBSEgI8+bNY/ny5eTk5Fx2hZU//vgDuLDGeEtLi8dtxq6/vmnTJhYtWkRlZSWtra0cOXIEk8lEREQEa9asITs7e/xOUkTkX/IzxhYrioiIiIjIpFINuYiIiIiIDymQi4iIiIj4kAK5iIiIiIgPKZCLiIiIiPiQArmIiIiIiA8pkIuIiIiI+JACuYiIiIiIDymQi4iIiIj4kAK5iIiIiIgP/QcM5O6AG2ZCbQAAAABJRU5ErkJggg==\n",
            "text/plain": [
              "\u003cFigure size 864x432 with 1 Axes\u003e"
            ]
          },
          "metadata": {
            "tags": []
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "#@title Time to price a batch of options (GPU vs QuantLib)\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "import time\n",
        "batch_of_options = [1, 10, 100, 150, 200, 250, 300, 350, 400, 450, 500, 600, 700, 800, 900, 1000, 10000]  #@param\n",
        "\n",
        "gpu_times = []\n",
        "cpu_times = []\n",
        "\n",
        "\n",
        "for options in batch_of_options:\n",
        "    \n",
        "  # Generate volatilities, rates, strikes\n",
        "  volatility, risk_free_rate, strike = option_param(options, dtype)\n",
        "\n",
        "  with tf.device(\"/gpu:0\"):\n",
        "    \n",
        "    # Warmup\n",
        "    estimate, _ = american_option(\n",
        "        time_delta=time_delta,\n",
        "        expiry=expiry,\n",
        "        number_grid_points=number_grid_points,\n",
        "        volatility=volatility,\n",
        "        risk_free_rate=risk_free_rate,\n",
        "        strike=strike,\n",
        "        dtype=dtype)\n",
        "    \n",
        "    # Timed run\n",
        "    t = time.time()\n",
        "    estimate, _ = american_option(\n",
        "        time_delta=time_delta,\n",
        "        expiry=expiry,\n",
        "        number_grid_points=number_grid_points,\n",
        "        volatility=volatility,\n",
        "        risk_free_rate=risk_free_rate,\n",
        "        strike=strike,\n",
        "        dtype=dtype)\n",
        "    time_gpu = time.time() - t\n",
        "    \n",
        "  gpu_times.append(time_gpu)\n",
        "\n",
        "# We hardcode QunatLib values here for simplicity\n",
        "ql_times = [1 / ql_options_per_second * i for i in batch_of_options]\n",
        "\n",
        "# Prepare Plotting \n",
        "plt.figure(figsize=(12, 6))\n",
        "sns.set(style=\"darkgrid\")\n",
        "sns.set_context(\"paper\", font_scale=1.5, rc={\"lines.linewidth\": 2.5})\n",
        "batches = batch_of_options * 2\n",
        "num_batches = len(batch_of_options)\n",
        "method = [\"Quantlib\"] * num_batches +  [\"Tensorflow\"] * num_batches\n",
        "times = ql_times + gpu_times\n",
        "data = {\"Batch Size\": batches,\n",
        "        \"Method\": method,\n",
        "        \"Times\": times}\n",
        "ql_gpu_times = pd.DataFrame(data = data)\n",
        "plot = sns.lineplot(x=\"Batch Size\", y=\"Times\", hue=\"Method\", style = \"Method\",\n",
        "                    data=ql_gpu_times, markers=True, dashes=False)\n",
        "#handles, labels = plot.get_legend_handles_labels()\n",
        "#plot.legend(handles=handles[1:], labels=labels[1:], loc=\"upper left\")\n",
        "plot.axes.set_title(\"Option Compute Time by Batch Size\", fontsize=20)\n",
        "xlabel = plot.axes.get_xlabel()\n",
        "plot.axes.set_xlabel(xlabel, fontsize=20)\n",
        "plot.axes.set_ylabel('Time in seconds', fontsize=20)\n",
        "plt.setp(plot.get_legend().get_title(), fontsize=15)\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "49XsRCZ8LkYw",
        "outputId": "51b5f970-a688-4179-eadf-ae2f8a064b6a"
      },
      "outputs": [
        {
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAu8AAAGcCAYAAABp3U6jAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAByb0lEQVR4nO3dd1gUV9sG8HsXliJViqKIDeNaUFBRRDFqrFGjYldiibGLGmPvWF4hJBqNaGIP2LBrjMZuVEBBQST2iIIgFoogiPT9/uDbCSt1KcLK/bsuL9mZMzPP7JmdffbMmTMimUwmAxERERERVXji8g6AiIiIiIiKhsk7EREREZGKYPJORERERKQimLwTEREREakIJu9ERERERCqCyTsRERERkYpg8k7lZuTIkZBKpdiwYUN5h5Inf39/SKVSSKXS8g7lo4iMjBT2NzIysrzD+SR88cUXkEqlOHLkSHmHUmTz58+HVCrF/PnzyzsU+oSU1vl+xIgRkEqluH37dilFRqTo3bt3aNu2LVq3bo03b96Udzh5Ui/vACh/GzZsgIeHR57ztLS0UL16dbRo0QJDhw5Fy5YtS337kZGROHr0KABg2rRppb7+yuTixYs4ffo0goODER0djaysLBgbG8PKygpdunRBnz59oKamVmbbl39hOjo6olatWmW2HVUycuRIBAQE5JpepUoVVKtWDS1atMCwYcNgY2Pz8YOjchcXF4f9+/fjypUrePLkCZKSkqCrqwsTExNYWFigZcuWsLW1LZNzL+XtzJkzCAwMRMeOHWFtbV1g2RcvXuDIkSPw9/dHWFgY4uPjAQAGBgawtLSEjY0NunfvjiZNmuS5fEnOD/IGH2dn50K/O3N+zz98+LDAsqokMzMTZ86cwd9//43bt28jNjYWKSkp0NPTQ926dWFra4uvvvoKDRs2VFguMjISXbp0ybU+sVgMPT091KtXDx06dMCIESNgZGSkUObIkSNYsGABAODChQuFftd98cUXeP78ORwdHeHm5iZM19HRwdixY7FmzRps3LgRixcvLu7bUGaYvKsIExMT4e+srCwkJCQgPDwc4eHhOHbsWJFOEsp6/vy5cFJh8l48ERERmDVrlkIrkZaWFtTU1PD8+XM8f/4cZ86cwa+//oq1a9fm+0VSUvJ6bNOmTb4nNIlEgnr16gl/VxYSiQQGBgbC6zdv3iAsLAxhYWHCZ8vZ2blY67awsICGhgb09PRKK1z6CK5du4bvvvtOSPiA7KQtIyMDjx8/xuPHj3Hp0iUAn1bCVZGlp6djzZo1AFDg5zEtLQ0//fQT9u7di/T0dGG6trY2JBIJoqOj8fr1a1y7dg2//vorbG1t4e7uDnNz8zzXV5bnh09VcHAw5s2bh7CwMGGaRCKBjo4O4uPjERQUhKCgIGzZsgXdu3fHmjVroKGhkWs9urq60NLSApBd/wkJCQgODkZwcDD27t2LzZs3o1mzZmWyD05OTtixYwe8vb0xcuRI1KlTp0y2U1xM3lWEr6+vwuvMzEwEBwfjf//7H+7evQsPDw+0b9+erUAVSGhoKEaOHInY2FhoaWnh22+/haOjIywsLAAAsbGxOHnyJDZu3IinT5/CyckJW7duha2tbbnEW716dZw+fbpctl2eWrRogV27dgmv09LScOPGDSxfvhzh4eHYsGEDrKys0KlTJ6XX7enpWYqR0scQFRWFKVOmIDk5Gebm5pg6dSq6desGfX19AEBiYiJu376Nixcv4s8//yznaCuPs2fPIjw8HFZWVmjevHmeZdLS0jB27FjcuHEDAODg4AAnJye0bt1a+AGdkZGB+/fv4+rVq9i/fz9u3ryJ0NDQfJP3sjw/fIouXryIGTNmIC0tDYaGhvj222/RvXt31K1bF0B27nLv3j2cPXsWe/fuxdmzZ5GSkpJn8r5o0SIMGDBAeJ2QkIC9e/di48aNiI2NxbRp03DmzBloamqW+n7o6Ojgq6++gpeXFzw9PbF06dJS30ZJsM+7ilJTU0OrVq2wadMmYdqFCxfKMSLKKSUlBTNmzEBsbCx0dXWxa9cuTJ8+XUjcAcDY2BijRo3CoUOHULNmTSQnJ+O7775DXFxcOUZOGhoaaN++PTZt2iRcgdi9e3c5R0Ufy/79+5GcnAyJRILdu3dj4MCBQuIOAHp6enBwcMDSpUtx5cqVcoy0cvH29gYA9O3bN98yy5cvFxL3JUuWYPv27fjiiy8Urnypq6ujWbNmmDJlCi5cuIBZs2YJrbtFwfND/sLCwjBnzhykpaWhQYMGOH78OCZMmCAk7kB27tKsWTPMmjULFy5cyLOLTH4MDAwwefJkjBs3DkB216iyzHvkx9off/yB9+/fl9l2ioMt7yrOzMwMhoaGiI+PR3Jycq756enpCAgIwKVLlxAUFITXr18jPj4eenp6aNKkCRwdHdG7d2+IRCKF5eR9weQ+vGnzwz5iAJCcnIz9+/fjwoUL+Pfff/Hu3TsYGRmhdu3a+OKLL9C3b1+F7j85yWQyHDx4EAcPHkRoaChkMhkaNmyIESNGoF+/fgW+B8+ePYOnpyf8/Pzw8uVLZGVloWbNmnBwcMA333yDmjVr5rtsaGgoNm3ahOvXr+Pt27eoVq0aOnXqhMmTJxe4zcIcPHgQ//77LwBg8eLF+bYUAdldK9zd3fH1118jOjoaW7duxbx58xTKyOvD1dUV3bt3x+bNm3H27Fm8ePEC2traaNWqFSZOnJirH+j8+fOF+xYAYNSoUQrzzc3NcfHiRQCKfQ3z6y+YmJgIT09PXLhwAeHh4cjIyICZmRns7e0xbtw4hR8nOcmPHy8vLzRt2hRbt27FmTNnEBUVBW1tbdjY2GDKlCn59mNNSEjA77//jr///hvh4eFIS0uDgYEBjIyM0KJFC3z55Zewt7fP9z0ujgYNGsDKygq3bt3CP//8I0yX96uUv3fXr1+Hl5cXQkJCEBsbi379+gmfjZz1lrMFKafbt2/D29sbN2/eRHR0NMRiMczMzGBtbY3evXvDwcEhz+XOnz+PI0eOICQkBPHx8dDW1kbDhg3Rp08fDBo0qMCuT3/88Qf27t2Lhw8fQiwWo379+hg0aBCGDBlSgnes+Mfph+7du4ddu3bhxo0bwntiYWGBzp07Y/To0bn6ugL/9R1u06YNdu3ahTNnzmD//v24f/8+3rx5g6lTpxap+9/9+/cBAI0bNy7w3AGg0KSvJHX04sUL7Nq1C76+voiMjER6ejqqVauGzz77DD169MCXX36Zq8UxMzMTR48exR9//IGHDx/i3bt3qFq1Klq0aAEnJyfY2dnluS15/255F5DinIszMzOxb98+HD58GE+fPoWGhgakUimcnJzQs2fPAt+nwoSFhSEgIAAikQi9e/fOs8zDhw9x+PBhAMDw4cPx9ddfF7pedXV1TJgwoVgx5Xd++BjS09PRoUMHvHnzBosWLcp1Xs/p4MGDWLx4MXR0dODr6wttbW0A2VcgDh8+jD///BOPHj0S7ukwNDRE48aN4eDggEGDBikV17p165CUlARNTU14eHjAzMyswPKGhobYtGkTZDKZUtvp168ffv31VwDAP//8g169eim1fFE1a9YMdevWRVhYGE6dOoWBAweWyXaKg8m7inv16pXQL1PeXzmnoKAgjB07VnitoaEBiUSCuLg4+Pj4wMfHB+fOncPPP/8Msfi/CzFVq1ZFUlISEhISACBX0q2rq6vw+u7du5g6dSpevHgB4L+bS16/fo1Xr17hxo0bEIvFGDNmTK4YMzMzMXXqVFy4cAHq6urQ0tLCu3fvhL5t4eHhmD59ep77f+DAAaxYsULo26ihoQGxWIwnT57gyZMnOHLkCH755Re0b98+17JXrlzB1KlTkZaWBiC7T2t0dDR2796NM2fOYObMmXlusyj27t0LIDsx79+/f6HlW7duDTs7O/j7++PAgQOYNWsW1NVzfzzfvn2LQYMG4enTp5BIJNDU1ER8fDwuXLiAS5cuYeXKlQonXPkNdjExMQCyWy5yJgxVq1Yt8j79+++/GDduHF6+fAkA0NTUhLq6unDvxZEjR/DTTz+hR48e+a4jOjoaAwYMQHh4ODQ1NSEWixEfH4+///4bvr6++PXXX9GhQweFZV6+fInhw4cjKioKwH/H1ps3bxATE4NHjx7h6dOnpZ68A9ldiYDs0Qfy4uXlhdWrV0Mmk0FPT0+pm44zMzPh6uqqcEm+SpUqyMrKQmhoKEJDQ3Hu3DncvHlTYbl3795h1qxZQp9rILueExMTcfPmTdy8eRPHjx/H5s2bFfrqAtk/khcuXCiMfiMSiaCvr487d+4gJCQE/v7+eV6+Vpayx2lOv/zyi8IXura2NtLT0/Hw4UMhQduyZUuB94e4ublh586dwv7lPLcV1evXryGTyXI1bBRFSeoIAI4dO4alS5ciNTUVQHZ/YS0tLURERCAiIgIXL16EVCpF48aNhWUSExMxZcoU4SZLNTU16OjoIDo6GmfOnMGZM2cwduzYXA0DORX3XJyWlobJkyfDx8cHQPZnVCKR4MaNGwgICMD48eOVfg9zunr1KgCgbt26+TYA7d27FzKZDOrq6iVufCmqws4PZUUikaBXr17Ys2cPjh8/XmDy/scffwAAevToISTumZmZmDBhgkJ3XD09PSQnJyM+Ph5hYWH466+/lEreY2JicObMGQDAV199lWc+kh9lP2M5fxQkJSUptayybG1tERYWhqtXr1ao5J3dZlRUZmYmbt26halTpwLI7oKRV5KopaWFPn36YMuWLfD19UVISAhu3boFf39/LFq0CLq6ujh9+nSuy36HDx9WGNLL19dX4V/Ou69fvHiBb7/9Fi9evECNGjXw888/IygoCAEBAQgJCcGJEycwbdq0PFvLgOyTbkBAANzc3BAYGIjAwEBcvnwZnTt3BgD8+uuvCje+yJ0/fx5LliwBAEyYMAEXL15ESEgIgoOD8ddff6Fnz55ISkrC9OnThcRP7uXLl5g5cybS0tIglUpx8OBB3Lp1C8HBwdi6dSvU1NRyXVkoqtevX+PJkycAgG7duhX5xNS9e3cA2Seju3fv5lnGw8MDcXFxWLduHYKDgxEYGIhTp06hTZs2yMrKwrJlyxSWXbx4scIJesOGDQr1KG+pKkxSUhImTZqEly9fonr16tiyZQuCg4MRFBSE48ePw8bGBmlpaZg9ezYePHiQ73pWrFgBiUQCT09PBAcH49atWzh48CDq1auH9PR0LFu2DFlZWQrLbNiwAVFRUTA3N8fvv/+OO3fuICAgAP/88w8uXrwIFxeXQltyi0t+9SmvBCsmJgZubm5wdHTE33//jZs3b+L27duYMmVKkda9du1aIXEfOHAgTp8+LRyDfn5+2LhxY64fMgAwd+5cXLp0CXXq1MGaNWuEz8zt27exadMmWFhY4NatW1i4cGGuZXft2iUk7l9//TX8/PwQEBCAgIAATJs2DadOnSqVy9DKHqdyv//+OzZu3IgqVapg1qxZ8PHxQXBwMG7fvo3Dhw+jbdu2iI6OxuTJk/NNmO7cuYOdO3di3Lhxwv4FBwfne+XjQ/KrZC9fvsQPP/yQ5xXNwpSkji5fvoz58+cjNTUVLVu2xJ49exASEoKbN28iMDAQe/bswZAhQ3K12i9atAgBAQGQSCRYvHgxAgMDcePGDYWkY8eOHdi3b1++cRf3XLxmzRr4+PhAJBLhu+++w40bN3Djxg34+vpi+PDh2Lp1q3BFozjkXWEKuoJ5/fp1AECTJk2EpLqsFXR+KGvy7/s7d+4gNDQ0zzJRUVHCe5fzqsmff/4JX19faGpqYtWqVQgKCsLNmzcREhICPz8/eHh4FNgIkxd/f3/h3N2tW7di7FHR5ewVUNbvvfy7Rf4+VhRM3lVE+/bthX/29vZo1qwZhg0bhqdPn+Krr77CwYMHFfplyllbW2PNmjXo2LEjTExMhETS0NAQo0aNwv/+9z8AUGj9U9batWvx5s0bGBoaYt++fejVq5fwC19DQwMNGzaEs7Nzvn0VExIS4OHhAUdHR+EytJmZGX755RdUq1YNWVlZ+OuvvxSWSUtLw4oVKwAALi4umDVrFszNzSESiSASiVC/fn2sX78eX3zxBZKSkrBz506F5X/77TckJSXB0NAQO3fuFL4UxGIxPv/8c2zdurXYfdweP34s/J2zZawwjRo1Ev5+9OhRnmUSExOxfv16fPnll0LLvKWlJbZu3Yq6desiIyMD69evL1bcBdm7dy8iIyMhkUiwbds2dOzYUWjNbNSoEbZv3w5zc3OkpaXh559/znc9ampq8PLyQtu2bSEWiyESidC8eXMh5ufPn+PWrVsKy8hff//997C3txdat9XU1GBubo7hw4dj9uzZpb7PISEhQoKZ14+D1NRUdOnSBa6urqhRo4YQU+3atQtd99OnT7Fjxw4AwLhx47B69WqFlipjY2N07do113v5999/4/z58zA1NcWuXbvQp08f4SqYpqYmunTpgt27d6NKlSo4f/68QsKUmpqKjRs3Asj+Il+yZInwg1pPTw/Ozs4YP3483r59W+T3KD/FOU7lyb5IJMLGjRsxYcIEmJqaAsh+X62srLB9+3Y0bdoUL1++xMGDB/PcdnJyMr755hvMmTNH2D8NDY18b0j80IgRI1CtWjUAwM6dO9G+fXuMGzcO69evx/nz5xEbG1vg8iWpo4yMDKxYsQIymQytWrWCp6cnbG1thc+arq4ubG1tsXLlSjRo0EBYLiQkRGj1XLJkCUaOHCmcg01NTbF69WohGVu/fr3Qov+h4pyLX716JTT+TJ48GZMnTxb219jYGC4uLujTpw8SExMLe+vzFRISAkDxHJlTRkaG8KNCmXNuSRR2fihrzZs3F84Zx48fz7PMiRMnIJPJUKNGDYUuU/Jzav/+/TF48GDo6OgAyG4BNzY2Rrdu3fDLL78oFY+8myhQ9nUgv7INoMyH8pXvS0xMDCIiIsp0W8pg8q4iYmJihH9xcXHIzMwEkH1jZFJSUqFfKPmR3yH/7NkzvH79Wunlk5OThZP5hAkThCRGGS1btkTbtm1zTdfQ0BD6+344HNuVK1fw6tUrmJiYFHgpS946Ib+cC2R3HZDHPGzYMBgbG+darmHDhkq3PMjlHF7O0NCwyMvl7MKScx05tWzZMs/uIfLRbIDsS8wl+aLMi/z96tGjR65xeYHspEJ+E9GVK1fy3f6QIUPyfL+lUqnQx/7Dupb/KI2Oji7+Dijh1atXOHbsGKZMmYKsrCyIRCKMHj06z7LF7S977NgxZGVlwdDQMN8uYXmRJ6x9+/bNt3XRzMxM+KKWdzcAsj8D8uNKfsXuQxMmTCiVkRuKc5yeOHEC79+/h5WVVb5doNTV1dGnTx8Aip/pnMRicYm6aRgZGWHv3r1CV7vk5GRcvXoVmzZtwtSpU9GuXTsMGDAAR44cyXWVCChZHfn7+wsPSFuwYEGRuzCdPHlSWO/gwYPzLDNjxgwA2UMdfjh6mVxxzsVnzpxBRkaGQt1+qCRDKcpkMuGzn9/V25zny4JaYpcuXarQECb/p0x8ypwfypq8NV2epH9IntT37dtX4QpwWZxTi/u9V1RpaWkIDQ3FqlWrhKtHdevWLfNRfnJ+LxcnRyor7POuIj48YaampuLJkyfYvXs3Dh06BF9fX/z888/o2rVrrmWTkpLg7e2Nv//+G6GhoUhMTFQY/1bu1atXQotTUd25c0dYl/zSqrIKarWQxyPvey8XGBgoTM/vhj4AQmw5u81ERkYKJ5q8vqjk2rZtW+Kh4IrTX7YghcULZD8H4O7duwWWVUZaWppw/BXUr1ye7BS0/cLqOjIyMlddd+rUCbdu3cKaNWvw5MkTdOvWDS1btsx130VxBQQE5PsUXYlEgvnz5+d5o5+WlhaaNm1arG0GBQUByH7PlEmW5cf9gQMH8m1tAyAkxTmP+zt37gAAatSoke+YxXp6emjatKkQX3EV5ziV79u///6b5z0qcikpKQCQqyucXO3atfP8gagMCwsL7NixA6Ghobhw4QKCg4Nx//59YZt3797FggULcPLkSWzatEmhDktSR/IWUVNTU6XGr5bXrZ2dXb79+y0tLVG9enW8evUKd+7cwRdffJGrTHHOxfJtW1lZ5fuZrFevnrBtZb19+xYZGRkASt5FIjExUbj/J6cP9ymn4p4fPoZ+/fph/fr1iIqKQkBAgEIcObvTfHij8eeff44tW7bg4sWLGDduHPr374/WrVuXqLuRsjedFsWCBQuEhy59qFatWti0aVOe94aVppw/RCrS01aZvKsoTU1NNG7cGP/73/+QkJCAc+fOYf78+fj7778VTqBPnz7FmDFjhJsMgewbwPT09ISTvPxkVpxuIjlPhEW9LP0h+SW7vMg/mPKTt5z8F3B6enqeJ+MPyb/wAShcpSjoZFXcE1lxP+w5y+bXclHUeEtzuMmEhAThSk9B2895E1F+2y9OXX/77bd48OAB/vrrLxw4cAAHDhyASCTCZ599BgcHBwwZMkSpm6M+lPMhLCKRCJqamsITFAcPHpzvug0NDYt1IyTw3+emsNFMckpPTxeOkcTExCJdXcnruC/suC5shIiiKM5xKv9Mp6SkKMSdn/zKlDRxz8nS0hKWlpbC6+joaFy4cAFbtmzB8+fP4ePjg3Xr1gk3gZa0juQtococF4Bydfvq1at8r9QW5/Op7LaVlbOLT35XInKeLwtKxH/++WeFrmgfjsaVl+KeHz6GmjVronXr1ggICMDx48cVknf5D8dmzZopHMNA9k2Ys2fPxrp163D16lXh6o+ZmRnatWuHfv36Kd348+GV49K47yDnQ5rEYjF0dXVRt25ddOjQAf3790eVKlVKvI3C5Pxhnl93s/LA5P0TMHjwYJw7dw6JiYm4fPmywlBaCxYswMuXL2Fubo65c+eibdu2Cie6zMxMYdSGsvjlXFbkl6s7dOiAbdu2FXs9pd0yDkDhRHnv3r0CxyXOKWff188++yzPMgXFWxb7UhG2L5FIsG7dOkyaNAlnz55FYGAgQkJC8OjRIzx69Aienp6YPXu2wqhKyvjwISxFpczIMvlR5j3L2UXj559/LvbwaBX1OJHv37Bhw7B8+fJib7s06iU/pqamGDZsGLp27Yq+ffsiNjYWhw8fxpw5cyAWi8u9joq6XFkcA2V1XBUlMVdXVxeG9CvJjbF5Kc75QVNTE6mpqUX6ESpvNCtud7V+/fohICAAZ86cwdKlS6GlpYWMjAyhK1V+o52NGzcOX331Ff766y/cuHEDt27dwsuXL3HkyBEcOXIEPXr0wJo1a4r8tO2c31n3798vleT9w4c0FSbn0K1FSbSL8t7nPObKojtQcbHP+ycgZ4u3vL8kkD0KjPwy7Nq1a9GzZ89cB19RWq0LIr+hDFC8A7ysyYcLy+/GzoLkbJnLeUXiQ8VpJQKyW6Dq168PADh37lyRfxSdPXsWQHZrg5WVVZ5lCoo357z8+oYWh4GBgZAQyYcCzUvOeaW5fblGjRph+vTp8PT0xI0bN/D777+jdevWyMzMhLu7e4Gj3FQ08s+NMp8ZTU1N4WEzH3ajKwr5cV/QMQQU/7jPqTjHaUk+0x+biYmJ8EyEhIQE4QpCSetIflzkPI8XhbxuC/p8Av+996X5+Szr40pDQ0O4mlxQq7q8pfjevXulcgyXhLwVuihxyMsUt0569uwJLS0tJCUlCSNF+fr6IjY2VhhSMj/Vq1fHmDFjsHHjRvj5+eGPP/4Q7pk4c+ZMgSMTfShnl61z584Va19KKmfrf2HvfWpqqnA8FfTe5zzmyuJ7rbiYvH8CPuwSI5fzRJ7fmMh+fn75rjdnl4D8ElArKyvhl3nOMY3LWsuWLQFkf0A/HAe7MLVq1RJ+xPj7++dbTj70WHEMHz4cQPaX8LFjxwotLx8PGci+qTO/fnwFxSufJxaLc9W3vFWsOFdX5A9bAQp+T+THklgsLnZf8KJSV1eHvb09Nm/eDA0NDchksgKP5YqmRYsWALK/ZJW5FCs/7k+fPp3nzZIFkf8gfPHiBZ49e5ZnmYKGKVVGcY5T+b7dvn37ozYEFFfOS/Y5u3OUpI7ky8bExCj14B953eYcru9DoaGhQkKjTH/6om77zp07+Y65HRYWVmhyXxD5yDoFjfYxYsQIiEQiZGRkCA/wKS/y819h947IZDKhga2450xdXV3hXjd5Vxn5/x06dFAq4ZRKpVi1apVwHCpzTjUxMRGGO/7zzz/x9OnTIi9bWlf9mzRpInzXye89yc+tW7eE7qAFvffyH9Lq6ur53itUHpi8fwJy3lSZs8U25yOh82qVTEpKKvAkl7PvfH7Dx2lrawvddLZs2VJoy09p+eKLL4RWqtWrVxfaXz/nnfAikUh44p+3t3ee/bMfP34sDL1WHEOGDBFa31etWiUMdZaXiIgIzJ07F0D2CTC/ERuA7BNSXolRamqqMPSgg4NDrmFD5XVZ3FFo5K03Z86cybNl9N27d0L3pY4dOyoceyUlf4hWXjQ0NISrAsXtf14eBgwYADU1NcTHxys1JJv8CahhYWGFdhdLTk5WeO/at28v9N3dtGlTnsts3bq1SJf6C1Oc47Rfv37Q0tJCZmYmVqxYIXyx5iUrK6tUhrTMy82bNws9n7x7905oXaxVq5bCfpSkjuzs7ISnFLu6uhZ47OckPwe/evUq3yE05cdZ1apV0a5duyKttyh69OgBdXV1pKSk5BqSV04+RGlx2draAkCBP2ikUqkw8ti+fftyPbvkY5KfL58/f17goAcnT54Ufqh++eWXxd6e/IZUX19fhIWFCS3w+XWZKey4ytnPXBnfffcdqlSpgpSUFEybNq3Q1u+EhARMmzat1EZHMzAwEG52379/f75XamQymfDZNDQ0LPDzcPv2bQDZCf7H6GNfVKrzbUe5REdH4+effxZuuLGxsRFa9IDs1gr5jU8LFy4URgUAsn91jho1qsDLkHXr1hVa1Q8ePJjvr+OZM2eiatWqiI+Px/Dhw3Hq1CkhAUhLS8ODBw/www8/FKkFuqg0NTXh4uICkUiEu3fvYvjw4bh69arCSSkiIgLe3t4YNGiQwriwADBx4kTo6OjgzZs3GDt2rPClIJPJ4OPjg/HjxytcxVCWlpYWNmzYIDypduTIkdiwYYNCi2JsbCy8vLwwaNAgREVFQVtbG2vXrs33CYJA9g+y6dOn4/Tp08KNY6GhoZgwYQKePHkCNTW1PIcelPdHlA/Hp6zhw4ejVq1aSE9Px/jx43H58mWhhe/hw4f49ttvhXHgv/vuO6XXX5DOnTtjzZo1CA4OVqjf8PBwzJ49G+/fv4dYLM7zgUYVVZ06dYQfadu2bcOiRYsUHn4TFxeHU6dO5RrSsWvXrsIDUNasWYNly5YptHClpaXh9u3b+PHHH9G5c2eFH6ZaWlrCA6SOHj2K//3vf8LNlUlJSdi4cSM2b96c5/MilFWc49TU1BSzZs0CkD1W+jfffIPAwEAhiZfJZAgNDcXOnTvRp0+fMrvS5+XlhU6dOmHlypXw8/NTaE1OSkrCqVOnMGzYMOGz/OG9FiWpIzU1NSxZsgQikQiBgYEYM2YMbt68KXzWkpKS4O/vj9mzZys8T6J58+bC0LYrV67E7t27hc95dHQ0Fi9ejNOnTwPIHjKyNIYDlatevbpwpXHTpk3YvHmz8J7FxcVhxYoV+OOPP0r0g75NmzYAslv3C/pRt3TpUrRu3RpA9vvw7bff4uLFiwrJYVZWFp4+fYpt27bh8uXLxY6pID179hRG7lmwYAF27NihUM+xsbHYsWOHMJKKtbV1iZL39u3bw9TUFBkZGZg1axZSUlJgYGCQ7whwU6ZMwYIFC3D58mWFH8Hx8fHYtGkTrl27BiC7IUYZ9erVw48//giJRIJ///0X/fr1w5YtWxAeHi6UyczMxL1797B+/Xp07dpV6C5aWmbOnAmJRILo6Gh8/fXXCnmBTCbD/fv3MXXqVOEm3enTpxeYlMuTd/lxVVHwhlUV8eHQaampqQonpIYNG+KXX35RuGlIJBJh6dKlcHZ2xr///ouBAwcKCen79++hra2NX3/9FWPGjMlzm9ra2ujXrx8OHTqEH3/8ER4eHqhatSpEIhF69OghjLBgZmaG7du3Y/LkyXjx4gVmzpwJNTU16Orq4u3bt0LSn9+QT8XVtWtXuLu7Y+nSpbh//z7GjRsHdXV16Orq5mrRkvdPlatZsybWrl2LadOm4f79+xg0aBB0dHSQmZmJlJQUmJqaYv78+Xk+AbGoGjRogAMHDmDmzJm4c+cOPDw84OHhAW1tbaipqSkkBXXr1sVPP/1U6OVsZ2dneHt7Y8aMGdDQ0ICmpqZwHIhEIri4uOS5jmHDhiEoKAhnzpzBxYsXYWRkBHV1dVSvXr1I/Rp1dXXx66+/Yty4cXj58qUwHrhEIhH2Q0NDAz/++GO+D1IprpiYGGzZsgVbtmyBWCyGnp4eUlJShO4mIpEI8+bNyzWiQkX33Xff4d27d9izZw8OHTqEQ4cOoUqVKpDJZELilVfC8+OPP2LRokU4efIkvL294e3tjSpVqkAikSAxMVGh28SHNxGOGjUK9+7dw/Hjx+Hl5YXdu3dDT08PSUlJyMzMRO/evaGhoVHoCByFKe5xOmrUKKSlpWHt2rXw9/fHiBEjIJFIoKOjg3fv3ikMcVtWN0iqq6sjPj4eu3fvFlpvdXR0IJPJFJ62KhaLMXbsWIwYMSLXOkpSRx07doSbmxuWLFmCwMBAODk5QUNDA1paWgqJ1odX6OQ/xgICArBy5Uq4urpCR0dH4Rw8duxYIdEuTXPmzEFoaCj8/Pywdu1arF+/XuH8P378eNy+fVvoGqgse3t7GBkZIS4uDtevX893KFFNTU3s2LEDP/74I/bt2wcfHx/heQBVqlSBpqYmkpKSFI4jW1tb4cpnaVFXV4eHhwecnZ1x+/Zt/PDDD/jhhx+gp6cHmUymcO63trbGxo0bS3SjtZqaGvr06YOdO3cKjXQ9e/bMd3Se1NRU4cZU4L8rsznj6tGjR77PDChI165d4enpiQULFiA8PBxr1qwRbnyVH4/y418kEqFPnz4laij7kJWVFdatW4e5c+fi0aNHCnnB+/fvFb43Jk+eDCcnp3zXlZSUJDxZ9auvviq1GEsDk3cV8eGNpRKJBKamppBKpejZsyf69euX5we1c+fO2L17N3777TcEBQXh/fv3MDU1xZdffonx48cLXTvys2zZMtSoUQNnzpxBRESEMCbxh0MgNm3aFKdOncLevXtx4cIFPHnyBMnJyTAzM4OFhQW6dOlSJgd/37590bZtW+zduxdXr17Fs2fPkJiYiCpVqsDS0hKtWrVC165d8/zV3KlTJxw9ehSbNm3C9evXkZiYCFNTU3Tu3BmTJ0/O95HTyqhduzYOHTqECxcu4PTp0wgODkZsbCzS09NRs2ZNNG3aFF27dkWfPn2KNF6tvr4+Dh06hM2bN+Ps2bN48eIFDA0N0aJFC0ycOFHhyktO8suq+/fvx6NHjxAdHa10f9yGDRvi5MmT8PT0xPnz5xEeHo60tDTUrl0b7dq1w7ffflukp4sqa8eOHfD390dgYCBevHghfBbq1KmDVq1awcnJKd8bfCsyNTU1LF26FL1798a+ffsQGBiImJgYaGlpoVatWrC2thYeSJST/ArN0KFDcfjwYQQFBSE6OhrJyckwNjaGpaUlOnTogG7duuUa8UEsFsPd3R3t2rXDvn378OjRI2RkZKBJkyYYNGgQhg4dWio/sot7nALZo2B069YNe/fuxbVr1/D8+XMkJiZCV1cXtWvXhp2dHbp27VpmT1Z0d3fHkCFD4Ofnh5CQEDx9+hRxcXHIysqCgYEBateujVatWsHR0THfH6olqSMgu7uDra0tvLy84Ovri6ioKKSnp6N27dpo2LAhunfvnuvHqp6eHn7//XccPXoUx48fx8OHD5GcnAwTExO0bNkSTk5OZTYeuaamJrZu3Yq9e/fiyJEjePr0KWQyGWxtbeHk5IQvv/wSI0eOLPb6NTQ0MGDAAGzbtg0nTpwo8DkAGhoaWLRoEb755hscOXIEAQEBePr0KeLj45GZmQlDQ0PUr18fNjY26NWrV6k3NshVq1YNe/fuxenTp3Hq1CncvXtX+N40MzND06ZN0atXL/Ts2bNUxirv37+/Qrel/LrMAMDixYtx5coV3LhxA+Hh4YiOjkZaWhqqVasGKysrODo6Cv3Xi6NVq1b466+/cPr0aVy6dAkhISGIjY3Fu3fvYGBggPr166N169bo169foTlIcchb9Pft2wdfX188ffoUSUlJ0NLSQu3atWFra4vhw4fnO36/3JkzZ5Camgpra+syO06KSyRTpfEBiSqpL774As+fP4erq6tSQ2cRfUw8TqmsREREoEePHtDS0oKPj0+F6n9Mn6ZRo0bB398fP/zwQ4E/hsoD+7wTERFRhWZhYYFBgwYJXc2IylJISAj8/f3x2WefVbguMwCTdyIiIlIB8psLd+zYoXD/AVFpk4/ONGfOnDJ98Ftxsc87ERERVXgmJib48ccfcf/+fTx//jzfJ1ETlcS7d+9gY2ODDh06KD3izsfC5J2IiIhUQteuXYWHEhGVBR0dHTg7O5d3GAXiDatERERERCqCfd6JiIiIiFQEu80o6c2bd8jK4sUKIiIiIip9YrEIVavq5DufybuSsrJkTN6JiIiIqFyw2wwRERERkYpg8k5EREREpCKYvBMRERERqQgm70REREREKoI3rJYSmUyGN2+ikZaWAoA3tBaPCBoaWqha1RQikai8gyEiIiKqcJi8l5KkpASIRCJUr14LIhEvaBSHTJaF+PgYJCUlQE/PsLzDISIiIqpwmGWWkvfvk6CnZ8jEvQREIjH09Kri/fuk8g6FiIiIqEJipllKsrIyoabGCxklpaamjqyszPIOg4iIiKhCYvJeithPu+T4HhIRERHlr1yT9/379+Orr75Cy5Yt0bJlSwwdOhSXL18W5qempmL58uWws7NDixYtMG3aNMTGxiqsIyoqChMmTIC1tTXs7e3h7u6OzEzFllt/f384OjrCysoK3bp1w7Fjxz7G7hERERERlapyTd6rVauGWbNm4fDhwzh8+DDs7e0xdepUhIaGAgBWr16NS5cuYd26ddi1axdev36N6dOnC8tnZmZi4sSJSE9Ph7e3N9zc3HDkyBF4eHgIZSIiIjBx4kTY2dnh+PHjGD16NBYuXAg/P7+Ptp/bt29G795d8pz3v/+54NtvR5bZthcvngtn5wlltn4iIiIi+njKtZN2586dFV5/99132Lt3L0JCQlCtWjUcPnwYa9asgb29PYDsZL5Xr174559/0KxZM/j4+CA0NBQ7d+6EiYkJGjdujBkzZmDt2rWYMmUKJBIJvL29YWFhgfnz5wMALC0tERgYCE9PT7Rr1+6j7zMRERERUXFVmD7vmZmZOHnyJN6/fw9ra2vcuXMH6enpaN++vVDG0tISNWvWRHBwMAAgODgYjRo1gomJiVDGwcEBb9++xZMnT4QyOdchLyNfx6cgNTWlvEPIpSLGRERERKTqyn14lIcPH2LYsGFITU1FlSpVsHHjRtSvXx93796FlpYWdHV1FcobGxsjJiYGABATEwNjY2OF+fJEPiYmBlKpNN8y8fHxSE9Ph0QiUSpeY2PdPKe/fi2Gunrev4XEYhEAUZ7zRSIRRCJAXV2MmJho/PbbRgQFBSI2NgbVqlVHly7d8O23E4Q4o6KiMGBAH7i4rIK//zVcvXoZjRo1gYfHb3j16iXc3P6HoKCbqFrVCN98M+7/15+97efPIzFwYF9s2bITzZtbAwCWLFmAc+fOYNcub3z2WUMAwKxZM6Cjo4sVK/6H9+/fY+PG9QgI8MerV69gZGSEdu3aY8qUadDR+e+9aNu2JaZP/x6vXr3AmTN/QVdXF4cO/YHU1FRs2fIrzp07gzdv4lCnTl1MmTIN7do55Psei8VimJrqFak+iIiIqOQys7KgJq4wbbpFoooxl4ZyT97r1auHY8eO4e3btzh79izmzZuHPXv2AMh75BGZTPHppfmNTpJz+odlPlyHMmJjk5CVlXv5rKwsZGRk5blMdnkZUlLS8lxOJgMyMrIQG/sGurr6cHaeCT09PUREPMOOHVsQFxeHuXMXAQAyM7O3sWHDz/j88y+wcqUbxGI1pKdnYs6cmYiPj8e8eUugqamB7ds34+3bt6hVywIZGVmoXr0mTE2rISgoEE2aNAMABAffgoaGJoKCglCvXgPIZDKEhNzGxIlTkJGRhaSkZGRkZGL8+MkwNKyK169fwctrBxYsmIu1az0U9mXPHk9YW7fE4sUrIJNlvx8LFszBvXt38e23E2FuXgsXL57DnDkzsW2bFz77TJrP+5WF6OjEItcJERERlYypqR6OBj4u7zCU4tiqwSeZL4jFonwbi4EKkLxraGigTp06AIBmzZrhn3/+wa5du9C9e3e8f/8eSUlJCq3vcXFxQuu6iYkJ7t69q7A+eau8vLXdxMREmCYXGxsLQ0NDpVvdSyIhIQGdOrXNc55U2hgAYGnZAM7O3wnTmzWzhpaWNtzcVmDmzLkK8TZp0gyzZs0TXl+75oNHjx5i8+bf0bSplbDeoUP7o1YtC6Fc8+Y2CAkJBgA8fx6J2NgY9O07ACEhtzBw4BCEhj5GYuJbNG/eAgBQtWpVzJ69QFg+IyMDNWrUxJQp4/Dy5UuYmZkJ84yMjLFihavw+ubNAPj5+WDDhs1o0aIVAKBNm7aIiHgGT88dWLXqB6XeQyIiIqLKrtyT9w/JZDKkpaXBysoKEokEfn5+6N69OwDg6dOniIqKgo2NDQDAxsYGmzdvRmxsrJCs+/n5QV9fH/Xr1xfKXLlyRWEbfn5+wjo+Fl1dXaxbtynX9B07tiI2NvvHhUwmw8GD+/DHH0cRFRWFtLRUodyrVy8VkvAPu53cu3cXRkbGQuIOAGZmNdCwYSOFctbWLbBlyyZkZWXh9u1bsLRsgPbtO+CHH1YBAG7fDoK+vgHq1asvLHP69Ens378HkZEReP/+vTA9IiJcIXm3t1eM6ebNABgbG6NZM2tkZGQI01u1ao2//vqzgHeLiIiIiPJSrsn7zz//jPbt26NmzZpITk7GyZMnERAQgEmTJkFPTw8DBw6Eq6sr9PX1oauri1WrVsHW1hbNmmV3+XBwcIClpSXmzp2LOXPmIDo6GuvWrYOTk5PQSj1s2DDs3r0b7u7uGDhwIK5fv47Tp09j69atH3Vf1dTU0KhRk1zTDQwMhOT9wIG92LhxPZycRqNFi1bQ09PD/fv3sHbtDwqJPABUrWqk8DouLhZVq1bNtf6qVY2QnPxOeG1j0wJJSYl48iQUt2/fgrV1CzRvbo24uFg8fx6J27eD0by5tdDV6PLlS1i1ahn69x+ECROmQl8/O96FC2cjLU2xG5CRkWJMCQnxiI2NzfOKg5qaWkFvFxERERHloVyT9zdv3mD+/Pl4/fo19PT0IJVKsW3bNmFoyIULF0IsFmP69OlIS0tDhw4dsGzZMmF5NTU1/Pbbb3BxccHQoUOhra0NR0dHTJs2TShjYWGBzZs3w83NDV5eXjAzM8OqVasq5DCRly5dQOfOXTBx4lRhWljY0zzLftiP38jIGG/evMlV7s2bOGhqagqv69WzhL6+AW7fvoXbt29h4sSp0NHRhaVlA4SEBOP27VsYOtQpR0zn0aSJFWbPni9Mu3UrsEgx6enpw9S0Glxdfypgr4mIiIioqMo1eV+xYkWB8zU1NbFs2TKFhP1D5ubmhbait23bViWeqpqamgKJRENh2tmzfxVp2caNm2Lnzq24e/eO0HXm5cuXePToAZo1sxbKiUQiNGvWHJcunUdkZARsbFoCAKytW+LkyT8QGxsDa+sWOWJKhYbGhzGdLlJMtrZtsH//HmhrV0GdOnWLtAwRERER5a/C9XmvzFq3tsOhQ/vRpIkVzM1r4ezZvxAZGVmkZe3t26NBg4ZYsmQeJk+eBg0NTWzf/luu7jVAdqK+adN61K5dR5hvbW2DQ4e8oaWlBan0v37yrVvbYe3aH+DpuR1Nmljh+nVfBAYGFHl/2rRpi5kzp8LJaRTq1bPEu3dJ+PffR0hLS8OkSc5FWg8RERERZWPyXoGMGTMe8fHx2Lr1VwBAx46d8d13szFv3sxClxWJRHBzWwt39//B1XUlqlatipEjv8HNm/6Ij49XKCtvWbe2bplrWpMmVlBX/++w6NdvAKKinuPgQW+kpaWhdes2WLbsf5g4cUyRYvrf/37Erl07ceDAPrx69RL6+gZo0KAhBg0aWujyRERERKRIJCvJoOeVUH7jvL98GQ4zszrlENGnh+8lERHRx8Vx3iuOwsZ5r3yPpSIiIiIiUlFM3omIiIiIVASTdyIiIiIiFcHknYiIiIhIRTB5JyIiIiJSEUzeiYiIiIhUBJN3IiIiIiIVweSdiIiIiEhFMHknIiIiIlIR6uUdAFUcsbEx8PLagWvXfBEd/Rr6+vqwsKiDnj17o3v3L6GhoQEHB1uhvI6ODurXt8S4cZPRqlVrAICz8wQ0atQEzs7fKaz78OH92LdvNw4dOvExd4mIiIjok8Lk/SMxrFoFEnW1j7Kt9IxMxL9JVmqZ588jMWXKt6hevQamT/8etWvXRWpqCsLCnuLEiWMwN6+FFi1aAQCWLFkBW9s2SEpKwp49npg79zt4ee2HuXmtstgdIiIiIvp/TN4/Eom6Go4GPv4o23Js1UDpZdas+QEmJtXw2287IBb/15vqs8+k6NatJ2QymTBNV1cPxsYmMDY2wdy5i3DhwlncuOHP5J2IiIiojLHPOyEhIR43blzH8OFfKyTuOYlEojynq6mpQV1dHRkZ6WUZIhERERGBLe8EIDIyEjKZDLVr1xGmvX//Hn37dhdejxz5DUaNGquwXFpaGnbv/h0pKSmwsWn10eIlIiIiqqyYvFOetLS0sHPnXgDAwoWzkZ7+X8v6kiXzoaYmRmpqKgwNq2L+/CVo0OCz8gqViIiIqNJg8k6oVasWRCIRwsPD0LBhIwDZ3WRq1bIAAEgkGgrlv/tuNlq2tIWurh4MDQ0V5uno6ODdu6Rc20hMTISOjm7Z7AARERFRJcE+7wQDA0O0bm2HvXu9kJmZWWh5Y2MT1KplkStxBwALizp4+PB+rumPHj2EhUXt0giXiIiIqNJi8k4AgFmz5iMmJgaTJn2Dq1f/xrNn4QgLe4o//zyOFy+ioKZWtGEuHR0HISzsKTZsWIvQ0McIDw/Drl2/w9f3CoYOHVGm+0BERET0qWO3GQIAmJvXws6de+DpuQO//LIW0dGvoaGhCUtLS4wdOx59+w4o8no2bNiCLVs2YcaMScjIyES9evXg7r4OzZpZl/FeEBEREX3aRLKcA3hToWJjk5CVlfste/kyHGZmdfJYIltFf0hTRVLYe0lERESly9RU76M9j6a0OLZqgOjoxPIOo9SJxSIYG+d/nyBb3j8SVU6miYiIiKhiYJ93IiIiIiIVweSdiIiIiEhFMHknIiIiIlIRTN6JiIiIiFQEk3ciIiIiIhXB5J2IiIiISEVwqEgiIiIqsY/5PJPSourPRaHKick7ERERlZhEXU0lH/JDpGrYbYaIiIiISEWw5Z0E0dGv8fvv23D9uh/i4mJhbGyCxo2bwslpFAwMDDF4cF+hrL6+AaTSRpg8eRoaNmwEABg06CsMH/41Bg4cqrBeD491ePDgHjw8tnzU/SEiIiL61DB5/0h09bWgrSn5KNt6n5qOpLcpSi3z/HkkJk0ai5o1zTFr1nzUqVMXycnvcPXqZXh4rMOiRS4AgA0bNqN27TqIi4vD5s0emD17BvbsOQQ9Pb0y2BMiIiIiyonJ+0eirSlBqzleH2VbgT+OQhKUS97XrHGDiYkJNm3aBjW1/244+uwzKQYPHo6kpEQAgIGBAYyNTWBsbIJ58xbD0bEX7t27Azs7+1LdByIiIiLKjX3eCQkJ8bhxwx/Dh49SSNzl8mtV19TUBACkp6eXaXxERERElI3JOyEyMhIymQx169Yt8jLJycn49VcPaGtXQZMmTcsuOCIiIiISsNsMKWX8+NEQi8VISUlBjRo1sWLFahgZGZd3WERERESVApN3Qq1atSASiRAWFiaMHJOfVavcUbt2HejrG+TqTqOjo4OkpKRcyyQlJUJXV7dUYyYiIiKqjMq128zmzZsxcOBAtGjRAvb29nB2dkZYWJhCmZEjR0IqlSr8W7p0qUKZqKgoTJgwAdbW1rC3t4e7uzsyMzMVyvj7+8PR0RFWVlbo1q0bjh07VsZ7pzoMDAxha9sG+/Z55XrfACAxMVH4u3r16jA3r5VnP3gLi9p4+PBBrumPHj2AhUWd0g2aiIiIqBIq1+Q9ICAATk5OOHDgAHbu3Im0tDSMHTsWKSmKI6UMHz4cPj4+wr+5c+cK8zIzMzFx4kSkp6fD29sbbm5uOHLkCDw8PIQyERERmDhxIuzs7HD8+HGMHj0aCxcuhJ+f30fb14ru++/nITo6GlOnjoefnw+eP4/E48f/wtNzOxYsmFWkdQwePAK+vlewa9fvCA8PQ2joY2zYsBZhYWFwdBxUxntARERE9Okr124z27dvV3jt5uYGe3t73Lt3Dy1bthSma2trw9TUNM91+Pj4IDQ0FDt37oSJiQkaN26MGTNmYO3atZgyZQokEgm8vb1hYWGB+fPnAwAsLS0RGBgIT09PtGvXrux2UIVYWNTG9u278Pvv2/HTT6548yYORkbGaNq0GaZN+75I67C2toGb21p4eW3Hnj2eUFdXg6VlQ3h4bEbNmuZlvAdEREREn74K1edd3j3DwMBAYfrRo0dx5MgRmJqaokuXLpg8eTK0tLQAAMHBwWjUqBFMTEyE8g4ODnBxccGTJ08glUoRHByM9u3bK6zTwcEB7u7uZbxH/3mfmo7AH0d9tG0VR/XqZpg3b1G+8318bha6Dnv79rC3b19oOSIiIiJSXoVJ3mUyGVxdXdGmTRtYWloK0/v27Qtzc3MYGxvjwYMHWLNmDcLCwrB+/XoAQExMDIyNFUc7kSfyMTExkEql+ZaJj49Heno6JJKyf/Jp0tsUpR+cRERERESUU4VJ3lesWIFHjx5h3759CtMHDx4s/C2VSlGtWjWMGTMGz58/h7l5dlcMkUiU5zpzTv+wjEwmK1acxsZ5j5ry+rUY6uocNr80iMVimJrm/WAoIiKi0sTvG9VWGeuvQiTvK1euxMWLF7F7925Ur169wLLW1tYAgGfPnsHc3BwmJia4e/euQpmYmBgAEFrbTUxMhGlysbGxMDQ0VLrVPTY2CVlZuRP/rKwsZGRkKbUuyltWVhaioxMLL0hERBWGqiZR/L7JxvqrOMRiUb6NxUA5jzYjk8mwYsUKnD17Fp6enrCwsCh0mfv37wOAcAOrjY0NHjx4gNjYWKGMn58f9PX1Ub9+faGMr6+vwnr8/PxgY2NTSntCRERERFT2yjV5X758Of744w+sWbMGOjo6iI6ORnR0tDBU5LNnz7Bx40bcuXMHkZGRuHDhAubNm4e2bduiQYMGALJvPLW0tMTcuXPx4MEDXL16FevWrYOTk5PQqj5s2DA8e/YM7u7uCA0NxZ49e3D69GmMHj263PadiIiIiEhZ5dptRt6/feTIkQrTXV1dMWDAAEgkEly7dg1eXl5ITk5GjRo10LNnT0yaNEkoq6amht9++w0uLi4YOnQotLW14ejoiGnTpgllLCwssHnzZri5ucHLywtmZmZYtWpVqQ8TKZPJ8u1/T0VT3HsRiIiIiCoDkYzZklLy6/P++nUkjIyqQ1297Eeu+ZRlZKQjLu4VqlWrVd6hEBGREkxN9XA08HF5h6EUx1YNPsk+08XB+qs4KnSf90+JtrYuEhPjIZPxptXiksmykJj4Btra+R+wRERERJVZhRht5lOgq2uAN2+i8epVJABezCgeETQ0tKCra1B4USIiIqJKiMl7KRGJRDAyqlbeYRARERHRJ4zdZoiIiIiIVASTdyIiIiIiFcHknYiIiIhIRTB5JyIiIiJSEUzeiYiIiIhUBJN3IiIiIiIVweSdiIiIiEhFMHknIiIiIlIRTN6JiIiIiFQEk3ciIiIiIhXB5J2IiIiISEUweSciIiIiUhFM3omIiIiIVASTdyIiIiIiFcHknYiIiIhIRTB5JyIiIiJSEUzeiYiIiIhUBJN3IiIiIiIVweSdiIiIiEhFMHknIiIiIlIR6uUdABERkZxh1SqQqKuVdxhFlp6Rifg3yeUdBhFVIkzeiYiowpCoq+Fo4OPyDqPIHFs1KO8QiKiSYbcZIiIiIiIVweSdiIiIiEhFMHknIiIiIlIRTN6JiIiIiFQEk3ciIiIiIhXB5J2IiIiISEUweSciIiIiUhFM3omIiIiIVIRSyfu+ffvQtWtXvHr1Ks/5r169QteuXXHw4MFSCY6IiIiIiP6jVPL+559/wtTUFNWrV89zfvXq1WFmZoY//vijVIIjIiIiIqL/KJW8P336FI0aNSqwjFQqxdOnT0sUFBERERER5aZU8p6YmAh9ff0Cy+jq6iIhIaFEQRERERERUW5KJe+mpqZ4+PBhgWUePnwIIyOjEgVFRERERES5KZW829nZ4erVq7h582ae82/evIkrV67A3t6+VIIjIiIiIqL/qCtTePz48fjrr7/wzTffYMSIEejQoQOqV6+OV69e4cqVK9i3bx80NDQwfvz4soqXiIiIiKjSUip5r1+/PtatW4dZs2bB09MTXl5ewjyZTAZdXV2sWbMGlpaWpR4oEREREVFlp1TyDgCdOnXC+fPncfToUdy+fRuJiYnQ09ODjY0N+vfvj6pVqxZ5XZs3b8bZs2fx5MkTaGlpoVWrVpg9ezbq1q0rlElNTYWbmxtOnTqFtLQ0ODg4wMXFBcbGxkKZqKgouLi4wN/fH1WqVIGjoyNmzZoFNTU1oYy/vz/c3Nzw77//okaNGpg6dSr69++v7O4TEREREZUbpZN3AKhatSrGjh1b4o0HBATAyckJzZo1Q2ZmJtauXYuxY8fi1KlT0NLSAgCsXr0aly9fxrp166Cnp4eVK1di+vTp2LNnDwAgMzMTEydOhImJCby9vfH69WvMmzcPmpqamDFjBgAgIiICEydOxLBhw/DTTz/h2rVrWLhwIapVq4Z27dqVeD+IiIiIiD6GYiXvpWX79u0Kr93c3GBvb4979+6hZcuWSExMxOHDh7FmzRrhJtjVq1ejV69e+Oeff9CsWTP4+PggNDQUO3fuhImJCRo3bowZM2Zg7dq1mDJlCiQSCby9vWFhYYH58+cDACwtLREYGAhPT08m70RERESkMpQabQYAsrKysGvXLgwZMgStWrVCkyZNhHn37t2Di4tLsR/SlJiYCAAwMDAAANy5cwfp6elo3769UMbS0hI1a9ZEcHAwACA4OBiNGjWCiYmJUMbBwQFv377FkydPhDI51yEvI18HEREREZEqUKrlPS0tDePHj0dAQAAMDAygo6OD5ORkYX6tWrVw+PBhGBkZYfr06UoFIpPJ4OrqijZt2gg3vMbExEBLSwu6uroKZY2NjRETEyOUydn/HYCQyMfExEAqleZbJj4+Hunp6ZBIJEWO09hYt/BCRERUaZia6pV3CFQCrD/VVhnrT6nkffv27fD394ezszOmTJmCjRs3YtOmTcJ8fX19tG7dGj4+Pkon7ytWrMCjR4+wb98+hekikShXWZlMVmiZD6d/WObDdRRVbGwSsrKKtywRERVMFb+Io6MTyzuECkEV6w5g/cmx/ioOsVhUYGOxUt1mTpw4gZYtW8LZ2RlisTjPpLlWrVqIiopSKsiVK1fi4sWL8PT0RPXq1YXpJiYmeP/+PZKSkhTKx8XFCa3rJiYmQiu8nPy1vLU9rzKxsbEwNDRUqtWdiIiIiKg8KZW8R0ZGwtrausAyBgYGSEhIKNL6ZDIZVqxYgbNnz8LT0xMWFhYK862srCCRSODn5ydMe/r0KaKiomBjYwMAsLGxwYMHDxAbGyuU8fPzg76+PurXry+U8fX1VVi3n5+fsA4iIiIiIlWgVPKupaUl3FSan6ioKOjr6xdpfcuXL8cff/yBNWvWQEdHB9HR0YiOjkZKSgoAQE9PDwMHDoSrqyuuX7+OO3fuYMGCBbC1tUWzZs0AZN94amlpiblz5+LBgwe4evUq1q1bBycnJ6FVfdiwYXj27Bnc3d0RGhqKPXv24PTp0xg9erQyu09EREREVK6U6vPeqFEj+Pr6Ii0tDRoaGrnmJyYmwsfHBy1atCjS+uT920eOHKkw3dXVFQMGDAAALFy4EGKxGNOnT0daWho6dOiAZcuWCWXV1NTw22+/wcXFBUOHDoW2tjYcHR0xbdo0oYyFhQU2b94MNzc3eHl5wczMDKtWreIwkURERESkUpRK3ocMGYLZs2dj9uzZWL16tcK8t2/fYsGCBXj79i2GDx9epPU9fPiw0DKamppYtmyZQsL+IXNzc2zdurXA9bRt2xbHjh0rUlxERERERBWRUsl7nz594OfnhyNHjuDixYvCeOwDBgzA48ePkZaWBicnJ3Ts2LFMgiUiIiIiqsyUfsLq6tWrYWtrCy8vLzx8+BAymQz37t3DZ599hjFjxmDgwIFlEScRERERUaWndPIOZLe0DxgwACkpKUhISICenh6qVKlS2rEREREREVEOxUre5bS0tKClpVVasRARERERUQFKlLwDwIULF3D9+nXIZDK0bt0aPXr0KI24iIiIiIjoA4Um7xcvXsT27dsxY8YMtGnTRmHeggULcOzYMchkMgDAnj170LVrV2zYsKFsoiUiIiIiqsQKfUjTxYsXce/evVxPVr106RKOHj0KLS0tTJ48GbNnz4aFhQXOnz+PP//8s8wCJiIiIiKqrApteQ8JCYGNjQ00NTUVph8+fBgikQiurq7o2bMnAKBfv37o1q0bTpw4gT59+pRNxERERERElVShLe8xMTGwsLDINf3GjRvQ19dX6ONuamqKjh074t69e6UbJRERERERFZ68v337FoaGhgrToqKikJCQgJYtW0IkEinMq1WrFuLj40szRiIiIiIiQhGSdx0dHbx8+VJh2t27dwEATZo0yXOZD7vYEBERERFRyRWavDds2BCXL1/Gu3fvhGnnzp2DSCRCq1atcpWPjIyEqalp6UZJRERERESFJ+9fffUVEhISMHLkSHh5eWHFihU4ceIETExMYGdnp1BWJpMhMDAQDRo0KLOAiYiIiIgqq0JHmxk0aBDOnj0LHx8f3L9/HzKZDOrq6li0aBHU1NQUyl67dg0xMTGwt7cvs4CJiIiIiCqrQpN3sViMLVu24MSJEwgODoahoSG6d++Oxo0b5yr75s0bjBo1Cl26dCmTYImIiIiIKrNCk3cgO4Hv168f+vXrV2C53r17o3fv3qUSGBERERERKSq0z3u/fv3g4eGBBw8efIx4iIiIiIgoH4Um7xkZGfDw8ICjoyO6desGd3d3BAUFfYzYiIiIiIgoh0K7zZw8eRJhYWE4e/Yszp8/j507d2Lnzp0wNjZGly5d0L17d9jZ2UFdvUg9cIiIiIiIqJiKlHHXrVsXEyZMwIQJE/Dq1SucP38e586dw+HDh3HgwAHo6uqiU6dO6NatGzp06ABtbe2yjpuIiIiIqNJRurm8evXqcHJygpOTExISEnDx4kWcO3cO586dw4kTJ6ClpYX27dujW7du6NSpEwwNDcsgbCIiIiKiyqdEfV0MDAzg6OgIR0dHpKSk4PLlyzh37hyuXLmCCxcuQF1dHXfu3CmtWImIiIiIKrVS66iupaWFHj16oEePHsjIyMD169dx/vz50lo9EREREVGlVyrJe3p6Ov79919oaWmhfv36UFdXh4ODAxwcHEpj9UREREREhCIMFZnTqVOnMGPGDMTHxwvTnj17hj59+mDgwIHo3bs3nJ2dkZGRUdpxEhERERFVekol74cPH8aTJ08UbkJ1c3NDeHg47OzsIJVKceHCBRw5cqS04yQiIiIiqvSUSt5DQ0PRrFkz4XVSUhKuXLmCL7/8Er///jsOHjyI+vXrM3knIiIiIioDSiXvcXFxMDU1FV7funULGRkZ6N27NwBAIpGgXbt2ePbsWelGSUREREREyiXvOjo6SEpKEl7fuHEDIpEILVu2FKZpamri3bt3pRchEREREREBUHK0mTp16uDKlStIS0sDAJw+fRpSqRRGRkZCmaioKBgbG5dulEREREREpFzL+9ChQxEREYHu3bujV69eiIiIwMCBAxXK3L59Gw0aNCjVIImIiIiISMnk3dHRERMmTMD79++RmJgIJycnfP3118L8a9eu4fnz57Czsyv1QImIiIiIKjulH9L0/fff4/vvv89zXqtWrXDjxg1oa2uXODAiIiIiIlJUKk9YldPQ0ICGhkZprpKIiIiIiP5fsZP35ORkJCYmIjMzM8/5NWvWLHZQRERERESUm9LJ+7Fjx7Bt2zaEhobmW0YkEuHevXslCoyIiIiIiBQplbwfOXIECxcuhJqaGmxtbWFmZgZ19VLteUNERERERPlQKvPesWMHDAwMsHfvXlhaWpZVTERERERElAelhooMDw9Hjx49mLgTEREREZUDpZJ3AwMDjiZDRERERFROlEreO3fujICAAMhksrKKh4iIiIiI8qFU8v79998jLS0Ny5Ytw7t370olgBs3bmDSpElwcHCAVCrFpUuXFOaPHDkSUqlU4d/SpUsVykRFRWHChAmwtraGvb093N3dcw1h6e/vD0dHR1hZWaFbt244duxYqcRPRERERPSxKHXD6owZM6CtrY2DBw/ixIkTqFu3LvT09HKVE4lE8PT0LNI6k5OTIZVKMWDAAEybNi3PMsOHD8fUqVOF1zmf4JqZmYmJEyfCxMQE3t7eeP36NebNmwdNTU3MmDEDABAREYGJEydi2LBh+Omnn3Dt2jUsXLgQ1apVQ7t27ZR5C4iIiIiIyo1SyXtAQIDw9/v373H//v08y4lEoiKvs2PHjujYsWOBZbS1tWFqaprnPB8fH4SGhmLnzp0wMTFB48aNMWPGDKxduxZTpkyBRCKBt7c3LCwsMH/+fACApaUlAgMD4enpyeSdiIiIiFSGUsn7gwcPyiqOAh09ehRHjhyBqakpunTpgsmTJ0NLSwsAEBwcjEaNGsHExEQo7+DgABcXFzx58gRSqRTBwcFo3769wjodHBzg7u7+UfeDiIiIiKgkKvwTlvr27Qtzc3MYGxvjwYMHWLNmDcLCwrB+/XoAQExMDIyNjRWWkSfyMTExkEql+ZaJj49Heno6JBJJkeMxNtYt4R4REdGnxNQ0d/dRUh2sP9VWGeuvwifvgwcPFv6WSqWoVq0axowZg+fPn8Pc3BxA/t10ck7/sExxR8yJjU1CVhZH2yEiKguq+EUcHZ1Y3iFUCKpYdwDrT471V3GIxaICG4uLlbyfPHkSBw8exP3795GYmAhdXV00bdoUgwYNQu/evYsdbFFYW1sDAJ49ewZzc3OYmJjg7t27CmViYmIAQGhtNzExEabJxcbGwtDQUKlWdyIiIiKi8qRU8i6TyTB37lz8+eefkMlkUFNTg5GREd68eYNr167h+vXruHjxItasWVNW8Qo3ycpvYLWxscHmzZsRGxsrJOt+fn7Q19dH/fr1hTJXrlxRWI+fnx9sbGzKLE4iIiIiotKm1Djv3t7eOHHiBJo0aYKdO3ciJCQEPj4+CAkJwc6dO9G0aVOcOnUK+/btK/I63717h/v37wtJeWRkJO7fv4/o6Gg8e/YMGzduxJ07dxAZGYkLFy5g3rx5aNu2LRo0aAAg+8ZTS0tLzJ07Fw8ePMDVq1exbt06ODk5Ca3qw4YNw7Nnz+Du7o7Q0FDs2bMHp0+fxujRo5XZfSIiIiKiciWSKdH5e9CgQXjz5g1OnjwpjPaSU0pKCvr06QMDAwMcPny4SOv09/fHqFGjck13dnbGoEGDMGfOHPz7779ITk5GjRo10L17d0yaNAm6uv/1BXr+/DlcXFwQEBAAbW1tODo6Yvbs2VBTUxPKXL9+HW5ubnj8+DHMzMwwdepUODo6FnXXBezzTkRUdkxN9XA08HF5h1Fkjq0afJJ9botD1eoOYP3lxPqrOEq1z3toaCiGDh2aZ+IOAFpaWujatSv2799f5HXa2dnh4cOH+c7fvXt3oeswNzfH1q1bCyzTtm1bPlWViIiIiFSaUt1mgMJHaSnuKC5ERERERFQwpZJ3S0tLnDt3DikpKXnOT0lJwfnz52FpaVkqwRERERER0X+USt4HDhyIqKgoODk54dq1a8jIyAAAZGZm4vr16xg1ahSioqIwcODAMgmWiIiIiKgyU6rP+7Bhw3Dz5k2cPHkSY8eOhVgshoGBARISEpCVlQWZTIYvv/wSw4cPL6t4iYiIiIgqLaWSd5FIhDVr1qBz5844fPgw7t27h4SEBOjq6qJJkyYYOHAg+vTpU1axEhERERFVasV6wmqfPn2YpBMRERERfWRKjzZDRERERETlg8k7EREREZGKKLDbTKNGjSAWi3Hy5EnUq1cPjRo1gkgkKnSlIpEI9+7dK7UgiYiIiIiokOS9devWAABtbW2F10RERERE9PEVmLzv2rWrwNdERERERPTxsM87EREREZGKUCp579KlC7y8vAoss2fPHnTp0qVEQRERERERUW5KJe/Pnz/H27dvCyzz9u1bREVFlSgoIiIiIiLKrdS7zSQnJ0MikZT2aomIiIiIKr1Cn7D6YSt6YmJini3rmZmZePHiBc6cOQMLC4vSi5CIiIiIiAAUIXn/4osvFMZ29/LyKrDfu0wmw/z580snOiIiIiIiEhSavPfv3x8ikQgymQzHjh2DVCpF48aNc5UTi8UwNDSEvb09HBwcyiRYIiIiIqLKrNDk3c3NTfj72LFj6Nq1K5ydncs0KCIiIiIiyq3Q5D2nBw8elFUcRERERERUCKWS95xevHiBe/fuITExEXp6emjSpAlq1KhRmrEREREREVEOSifvYWFhWL58Oa5fv55rXtu2bbF06VLUq1evVIIjIiIiIqL/KJW8h4eHY9iwYYiPj0ft2rXRqlUrmJiYICYmBoGBgbh27RpGjBgBb29v1KlTp6xiJiIiIiKqlJRK3tesWYP4+HgsWrQITk5OEIv/e8ZTVlYWdu3aBVdXV6xduxbr168v9WCJiIiIiCozpZL369evo2PHjhg5cmSueWKxGKNHj4avry+uXbtWagESEREREVE2ceFF/pOeno5GjRoVWKZx48ZIT08vUVBERERERJSbUsm7VCrFs2fPCiwTHh4OqVRaoqCIiIiIiCg3pZL3SZMm4dy5c7h8+XKe8//++2+cP38ekydPLpXgiIiIiIjoP0r1eY+Pj0eHDh0wadIk2Nvbw9bWVhht5saNG7h+/To6d+6MN2/e4NixYwrL9u/fvxTDJiIiIiKqfJRK3ufPnw+RSASZTAY/Pz/4+fnlKnPx4kVcunRJeC2TySASiZi8ExERERGVkFLJu6ura1nFQUREREREhVAqeXd0dCyrOIiIiIiIqBBKJe8AEBAQgKCgILx+/RoikQimpqZo2bIl2rRpUxbxERERERHR/yty8h4QEAAXFxc8ffoUQHZfdgAQiUQAgPr162PZsmVM4omIiIiIykiRkvczZ85g1qxZyMjIQLVq1dCmTRvUqFEDMpkML1++REBAAEJDQzF27FisXbsW3bt3L+u4iYiIiIgqnUKT91evXmH+/PlQU1PD4sWLMXjwYKipqSmUycrKwqFDh7B69WrMmzcP1tbWqF69epkFTURERERUGRX6kCZPT0+8f/8eP/30E4YNG5YrcQcAsViMIUOG4KeffsL79+/h5eVVJsESEREREVVmhSbvV69ehbW1Nbp161boyrp27Qpra2tcuXKlVIIjIiIiIqL/FJq8R0VFoUWLFkVeYYsWLfD8+fMSBUVERERERLkVmrxnZGRAIpEUeYXq6urIysoqUVBERERERJRbocm7qakpHj16VOQVPn78GCYmJkUuf+PGDUyaNAkODg6QSqW4dOmSwvzU1FQsX74cdnZ2aNGiBaZNm4bY2FiFMlFRUZgwYQKsra1hb28Pd3d3ZGZmKpTx9/eHo6MjrKys0K1bNxw7dqzIMRIRERERVQSFJu+tW7eGr68vQkNDC11ZaGgofHx80Lp16yIHkJycDKlUiqVLl+Y5f/Xq1bh06RLWrVuHXbt24fXr15g+fbowPzMzExMnTkR6ejq8vb3h5uaGI0eOwMPDQygTERGBiRMnws7ODsePH8fo0aOxcOFC+Pn5FTlOIiIiIqLyVmjy7uTkhIyMDEyaNAmPHz/Ot1xoaCgmTZqEzMxMjBgxosgBdOzYETNnzsxzbPjExEQcPnwYCxYsgL29PaysrLB69WrcvHkT//zzDwDAx8cHoaGh+PHHH9G4cWN07NgRM2bMwO7du5Geng4A8Pb2hoWFBebPnw9LS0t8/fXX6NGjBzw9PYscJxERERFReSs0ebeyssK3336LiIgIODo6YtasWTh48CB8fHzg6+uLgwcP4vvvv0f//v0RERGBMWPGoFmzZqUS3J07d5Ceno727dsL0ywtLVGzZk0EBwcDAIKDg9GoUSOFrjoODg54+/Ytnjx5IpTJuQ55Gfk6iIiIiIhUQZGesDpnzhxoa2vjt99+w8mTJ3Hq1CmF+TKZDGpqapgyZQqmTZtWasHFxMRAS0sLurq6CtONjY0RExMjlDE2NlaYL0/kY2JiIJVK8y0THx+P9PR0pW7IJSIiIiIqL0VK3gHA2dkZjo6OOHz4MIKCghAdHQ2ZTAZTU1O0atUKjo6OsLCwKPUARSJRrmkymazQMh9O/7DMh+soKmNj3cILERFRpWFqqlfeIVAJsP5UW2WsvyIn7wBgbm6ucLNoWTMxMcH79++RlJSk0PoeFxcntK6bmJjg7t27CsvJW+Xlre0mJibCNLnY2FgYGhoq3eoeG5uErKziJf5ERFQwVfwijo5OLO8QKgRVrDuA9SfH+qs4xGJRgY3FhfZ5L09WVlaQSCQKo8I8ffoUUVFRsLGxAQDY2NjgwYMHCsNH+vn5QV9fH/Xr1xfK+Pr6Kqzbz89PWAcRERERkSoo9+T93bt3uH//Pu7fvw8AiIyMxP379xEdHQ09PT0MHDgQrq6uuH79Ou7cuYMFCxbA1tZWuCnWwcEBlpaWmDt3Lh48eICrV69i3bp1cHJyElrVhw0bhmfPnsHd3R2hoaHYs2cPTp8+jdGjR5fbfhMRERERKUupbjNl4c6dOxg1apTwetWqVQCy+9hPmzYNCxcuhFgsxvTp05GWloYOHTpg2bJlQnk1NTX89ttvcHFxwdChQ6GtrQ1HR0eFG2ctLCywefNmuLm5wcvLC2ZmZli1ahXatWv38XaUiIiIiKiERLLi3rlZSbHPOxFR2TE11cPRwPyfKVLROLZq8En2uS0OVas7gPWXE+uv4lDpPu9ERERERPQfJu9ERERERCqCyTsRERERkYpg8k5EREREpCKYvBMRERERqQgm70REREREKoLJOxERERGRimDyTkRERESkIpi8ExERERGpCCbvREREREQqgsk7EREREZGKYPJORERERKQimLwTEREREakIJu9ERERERCqCyTsRERERkYpg8k5EREREpCKYvBMRERERqQgm70REREREKoLJOxERERGRimDyTkRERESkIpi8ExERERGpCCbvREREREQqgsk7EREREZGKYPJORERERKQimLwTEREREakIJu9ERERERCqCyTsRERERkYpg8k5EREREpCKYvBMRERERqQgm70REREREKoLJOxERERGRimDyTkRERESkIpi8ExERERGpCCbvREREREQqgsk7EREREZGKYPJORERERKQimLwTEREREakIJu9ERERERCqCyTsRERERkYpg8k5EREREpCKYvBMRERERqYgKn7xv2LABUqlU4V/Pnj2F+ampqVi+fDns7OzQokULTJs2DbGxsQrriIqKwoQJE2BtbQ17e3u4u7sjMzPzY+8KEREREVGJqJd3AEXRqFEjbNu2TXitpqYm/L169WpcvnwZ69atg56eHlauXInp06djz549AIDMzExMnDgRJiYm8Pb2xuvXrzFv3jxoampixowZH31fiIiIiIiKq8K3vAPZybqpqanwz8jICACQmJiIw4cPY8GCBbC3t4eVlRVWr16Nmzdv4p9//gEA+Pj4IDQ0FD/++CMaN26Mjh07YsaMGdi9ezfS09PLc7eIiIiIiJSiEsn7kydP4ODggC5dumDOnDl4+fIlAODOnTtIT09H+/bthbKWlpaoWbMmgoODAQDBwcFo1KgRTExMhDIODg54+/Ytnjx58lH3g4iIiIioJCp88m5tbQ13d3ds374dLi4uiIiIgJOTE5KTkxETEwMtLS3o6uoqLGNsbIyYmBgAQExMDIyNjRXmyxN5eRkiIiIiIlVQ4fu8f/7558LfUqkU1tbW6Ny5M86cOQN1dXWIRKJcy8hkMoXXeZUpaHpBjI11Cy9ERESVhqmpXnmHQCXA+lNtlbH+Knzy/iF9fX3UrVsX4eHhsLOzw/v375GUlKTQ+h4XFye0rpuYmODu3bsK65C3uH/YIl8UsbFJyMqSFV6QiIiUpopfxNHRieUdQoWginUHsP7kWH8Vh1gsKrCxuMJ3m/nQu3fvEBERAVNTU1hZWUEikcDPz0+Y//TpU0RFRcHGxgYAYGNjgwcPHigMH+nn5wd9fX3Ur1//Y4dPRERERFRsFb7l/YcffkDnzp1Rs2ZNvH79Ghs2bICamhp69eoFPT09DBw4EK6urtDX14euri5WrVoFW1tbNGvWDED2zamWlpaYO3cu5syZg+joaKxbtw5OTk6QSCTlvHdEREREREVX4ZP3ly9f4vvvv0d8fDyMjIxga2uLAwcOoGrVqgCAhQsXQiwWY/r06UhLS0OHDh2wbNkyYXk1NTX89ttvcHFxwdChQ6GtrQ1HR0dMmzatvHaJiIiIiKhYRLIP7+6kArHPOxFR2TE11cPRwMflHUaRObZq8En2uS0OVas7gPWXE+uv4vjk+rwTEREREVVWTN6JiIiIiFQEk3ciIiIiIhXB5J2IiIiISEUweSciIiIiUhFM3omIiIiIVASTdyIiIiIiFcHknYiIiIhIRTB5JyIiIiJSEUzeiYiIiIhUBJN3IiIiIiIVoV7eARARlSbDqlUgUVcr7zCUkp6Rifg3yeUdBhERqQAm70T0SZGoq+Fo4OPyDkMpjq0alHcIRESkIththoiIiIhIRTB5JyIiIiJSEUzeiYiIiIhUBJN3IiIiIiIVweSdiIiIiEhFMHknIiIiIlIRTN6JiIiIiFQEk3ciIiIiIhXB5J2IiIiISEUweSciIiIiUhFM3omIiIiIVASTdyIiIiIiFcHknYiIiIhIRTB5JyIiIiJSEUzeiYiIiIhUBJN3IiIiIiIVweSdiIiIiEhFMHknIiIiIlIRTN6JiIiIiFQEk3ciIiIiIhXB5J2IiIiISEUweSciIiIiUhFM3omIiIiIVIR6eQdARFTZpaZnwtRUr7zDKLL3qelIeptS3mEQEVVKTN6JiMqZpkQNreZ4lXcYRRb44ygkgck7EVF5YPJO9AnQ1deCtqakvMNQCltv6VOgaldNAH72cmL9kSpi8k70CdDWlKhUyy3A1lv6NKjaVROAn72cWH+qTdV+fJXWDy8m70RERESkclTtx1dp/fCqVKPN7NmzB1988QWaNWuGIUOGICQkpLxDIiIiIiIqskrT8n7q1Cm4urpi+fLlsLa2hqenJ8aNG4fTp0/DyMiovMOjCsSwahVI1NXKOwwiIiKiXCpN8r5z504MHToUAwcOBAAsX74cf//9N44ePYpvv/22nKOjikSiroajgY/LOwylOLZqUN4hEBER0UdQKZL3tLQ03L17F5MnTxamicVitGvXDsHBwUqtSywWlXJ0FYeOria0VGjEkpTUdLxLSi2TdVfRUL2PRo2qOuUdgtLK6vPE+it7ZXkuVLX6U7W6A/jZy4n19x/WX9krSt0VVkYkk8lkpRVQRfXq1St8/vnnOHjwIJo3by5Md3d3R1BQELy9vcsxOiIiIiKioqlUN6x+SCaTQST6dFvSiYiIiOjTUimS96pVq0JNTQ0xMTEK0+Pi4mBiYlJOURERERERKadSJO8aGhpo2rQp/Pz8hGlZWVm4du0abGxsyi8wIiIiIiIlqN6dCcX0zTffYO7cuWjatCmaN28OT09PpKSkwNHRsbxDIyIiIiIqkkqTvPfq1QtxcXH45ZdfEB0djcaNG2Pbtm0c452IiIiIVEalGG2GiIiIiOhTUCn6vBMRERERfQqYvBMRERERqQgm70REREREKoLJOxERERGRimDyXsnduHEDkyZNgoODA6RSKS5dulTeIVE+Cqur1NRULF++HHZ2dmjRogWmTZuG2NjYcoq2ciuNuoqKisKECRNgbW0Ne3t7uLu7IzMz82PuRqXwserK398fjo6OsLKyQrdu3XDs2LGy3rVP3ubNmzFw4EC0aNEC9vb2cHZ2RlhYmEIZ1l/FtWHDBkilUoV/PXv2FOaz7vLH5L2SS05OhlQqxdKlS8s7FCpEYXW1evVqXLp0CevWrcOuXbvw+vVrTJ8+/SNHSUDJ6yozMxMTJ05Eeno6vL294ebmhiNHjsDDw+Nj7UKl8THqKiIiAhMnToSdnR2OHz+O0aNHY+HChQoPDiTlBQQEwMnJCQcOHMDOnTuRlpaGsWPHIiUlRSjD+qvYGjVqBB8fH+Hf3r17hXmsuwLIiP5fw4YNZRcvXizvMKgIPqyrt2/fypo2bSo7ffq0MO3x48eyhg0bykJCQsojRPp/xamrv//+W9a4cWNZdHS0UGbv3r0yW1tbWVpa2scLvpIpq7pyd3eX9enTR2Fb3333nWzChAlluTuVTmxsrKxhw4aywMBAmUzG+qvofvnlF5mjo2Oe81h3BWPLO9En4M6dO0hPT0f79u2FaZaWlqhZsyaCg4PLLzDKpSh1FRwcjEaNGsHExEQo4+DggLdv3+LJkycfO+RKq7TqKjg4WGEd8jL8bJauxMREAICBgQEA1p8qePLkCRwcHNClSxfMmTMHL1++BMC6KwyTd6JPQExMDLS0tKCrq6sw3djYGDExMeUUFeWlKHUVExMDY2NjhfnyLyjW58dTWnWVX5n4+Hikp6eXVfiVikwmg6urK9q0aQNLS0sArL+KztraGu7u7ti+fTtcXFwQEREBJycnJCcns+4KoV7eARBR6RCJRLmmyfgA5QqpKHWVV5mCplPZKK26+rAMP5ula8WKFXj06BH27dunMJ31V3F9/vnnwt9SqRTW1tbo3Lkzzpw5A3V1ddZdAdjyTvQJMDExwfv375GUlKQwPS4uTuGSIpW/otSViYlJrhZ2+esPW5Go7JRWXeVVJjY2FoaGhpBIJGUVfqWxcuVKXLx4EZ6enqhevbownfWnWvT19VG3bl2Eh4ez7grB5J3oE2BlZQWJRKJwB/3Tp08RFRUFGxub8guMcilKXdnY2ODBgwcKw6L5+flBX18f9evX/9ghV1qlVVc2Njbw9fVVWLefnx8/myUkk8mwYsUKnD17Fp6enrCwsFCYz/pTLe/evUNERARMTU1Zd4Vgt5lK7t27d3j27JnwOjIyEvfv34eJiQlMTU3LMTL6UGF1NXDgQLi6ukJfXx+6urpYtWoVbG1t0axZs3KMunIqaV05ODjA0tISc+fOxZw5cxAdHY1169bByclJpVuLKqKPUVfDhg3D7t274e7ujoEDB+L69es4ffo0tm7dWi77/KlYvnw5/vzzT2zatAk6OjqIjo4GAOjp6UFLSwt6enqsvwrshx9+QOfOnVGzZk28fv0aGzZsgJqaGnr16sW6K4RI9il0/qFi8/f3x6hRo3JNd3Z2xrRp08ohIspPYXWVmpoKNzc3nDx5EmlpaejQoQOWLVvGbjPloDTq6vnz53BxcUFAQAC0tbXh6OiI2bNnQ01N7WPuyifvY9XV9evX4ebmhsePH8PMzAxTp06Fo6PjR9nHT5VUKs1zuqurKwYMGAAArL8KbObMmbhx4wbi4+NhZGQEW1tbzJw5U7iCwrrLH5N3IiIiIiIVwT7vREREREQqgsk7EREREZGKYPJORERERKQimLwTEREREakIJu9ERERERCqCyTsRERERkYpg8k5ERCUWGRkJqVSK+fPnl8v2/f39IZVKsWHDhnLZPhHRx8InrBIRVUB5PYBGIpGgWrVqaN26NSZMmABLS8tS2U6bNm2wa9euEq+rtP311184dOgQ7t27h7dv30JXVxfGxsZo0qQJ2rdvr/IPWiEiKg4m70REFZizs7Pwd2JiIkJCQnDs2DGcPXsWe/fuRePGjcsxurKzZMkSHDhwAFpaWujYsSNq1aqF9+/fIyIiApcuXUJAQIBC8t68eXOcOnUKVatWLceoiYjKHpN3IqIKbNq0abmmrVy5Ert374anpyfc3NzKIaqyFRgYiAMHDsDMzAz79++HmZmZwvz09HQEBAQoTNPW1i6VKxFERBUd+7wTEamY9u3bAwDi4uIUpicmJmLbtm0YNWoUPv/8c1hZWaFt27aYNGkSgoODFcoeOXJE6JoTEBAAqVQq/Puw33hISAi+++47dOjQAVZWVnBwcMDYsWNx6tSpPOOLjIzEzJkzYWdnh2bNmmHAgAG4dOlSkfcvKCgIANC9e/dciTuQ3X1I/h7I5dXnfcOGDQr7lde/D129ehXjx4+HnZ0drKys0LVrV/zwww94+/ZtkeMnIipLbHknIlIxfn5+AAArKyuF6aGhoVi3bh1sbW3RqVMn6Ovr48WLF7h48SKuXr2KX3/9FZ9//jkAoHHjxnB2doaHhwfMzc0VuqC0adNG+PvAgQNwcXGBWCzGF198gbp16yI2NhZ37tzBvn370KtXL4UYnj9/jsGDB8PCwgL9+vVDQkICTp06hSlTpmDnzp1o27ZtoftnaGgIAAgLCyvO26OwHzm7Hcm9ePEChw8fhpaWlsJ0Dw8PbNiwAYaGhujUqROMjIzw6NEj7NixA1euXMH+/fuhq6tbopiIiEqKyTsRUQWWsyU5KSkJ//zzD4KCgtC5c2eMHTtWoaylpSWuXLkCIyMjhekvX77EoEGD4OrqqpC8N27cWEje8+qe8/jxYyxfvhy6urrYs2cPPvvss1zr/VBAQACmTZumkDT36dMH48aNw/bt24uUvH/++efQ09PDlStXMGnSJPTu3RvNmjVDnTp1IBKJCl1ezs7ODnZ2dgrTkpKSMHz4cIjFYvz444/C9OvXr2PDhg1o0aIFtmzZAn19fWHekSNHsGDBAvzyyy9YuHBhkbdPRFQWmLwTEVVgHh4euaY1aNAAvXv3ztUKrKenl+c6zMzM0LNnT+zatQtRUVGoWbNmkba9b98+ZGRkYMqUKbkSd/l6P2Rubo7JkycrTOvQoQNq1qyJkJCQIm23evXq8PDwwJIlS3Dp0iWhy42Ojg5atGiBvn37ok+fPlBTUyvS+uQyMjIwY8YMPHr0CPPnz0f37t2FefLRdlauXKmQuAPAgAED4OXlhRMnTjB5J6Jyx+SdiKgCe/jwofB3cnIyHj9+jJ9++gmzZ8/G48ePMXPmTIXygYGB8PLyQnBwMGJjY5Genq4w/9WrV0VO3uX95Dt06FDkeBs1apRnUm1mZpar331B2rZtizNnziAoKAgBAQG4f/8+goKC4OPjAx8fHxw7dgybN2+GhoZGkdfp4uICHx8fjBgxAt98843CvODgYEgkEpw+fRqnT5/OtWx6ejri4uLw5s0bjmhDROWKyTsRkYqoUqUKmjdvDg8PD3Ts2BHbtm3DsGHDUKNGDQDAuXPnMH36dGhqaqJdu3aoXbs2tLW1IRaLERAQgICAAKSlpRV5e4mJiQCyW8KL6sNWazl1dXVkZWUVeT0AIBaLYWtrC1tbWwCATCaDr68v5s+fDz8/P+zduxdjxowp0ro2b96MgwcPolOnTli8eHGu+fHx8cjIyMjzSkdOycnJTN6JqFwxeSciUjH6+vqoV68e7t69i7t37wrJ+/r16yGRSHD48OFcwyYuXbo01/CKhZF3w3n16lWFuFFTJBLBwcEBM2bMwOLFi3H9+vUiJe+nTp3Czz//jCZNmmDt2rV5XhnQ1dWFTCZT+j0iIvrYOFQkEZEKSkhIAJDdGi0XHh6OBg0a5Ercs7KyEBgYmOd6xGIxMjMz85xnY2MDIHv4xIpER0enyGWDgoIwf/58VK9eHb/99lu+y9rY2CAhIQH//vtvaYVJRFQmmLwTEamY8+fPIzIyEhKJBC1atBCmm5ubIywsDK9evRKmyWQyeHh44PHjx3muy9DQMM9RYwBg+PDhUFdXx6ZNm/JcPr/lSurKlSs4e/Zsrv76APDu3Tt4eXkBgNCdJj/h4eGYMmUK1NXVsXnz5gK7/8hb8JcsWaLw/sklJycr1WefiKissNsMEVEFlnOoyOTkZISGhuLKlSsAgJkzZ8LExESYP2bMGCxbtgyOjo7o3r071NXVERQUhNDQUHTu3DnPByXZ29vj5MmTmDRpEpo2bQo1NTW0bt0arVu3RoMGDbBs2TIsW7YM/fv3R5cuXVC3bl28efMGd+7cgY6OjjBKS2l68uQJXF1dYWBggFatWqFu3bpQU1PDy5cvcfnyZbx9+xbW1tb4+uuvC1zPqlWr8ObNG7Rt2xbnzp3DuXPncpWRD5Fpb2+PWbNmYe3atejRowc+//xz1KpVC8nJyYiKisKNGzfQsmVLbN++vdT3l4hIGUzeiYgqsJw3UKqpqcHIyAidO3fG119/nespo8OGDYOGhgY8PT1x7NgxaGpqwtbWFq6urjh79myeyfuiRYsgEolw7do1XL58GVlZWXB2dkbr1q0BAEOGDMFnn32GHTt2ICAgABcuXIChoSGkUikGDx5cJvvct29f6Orqws/PDw8ePMDNmzeRnJwMPT09NGrUCD179sTgwYMLHWkmJSUFQPYY7tevX8+zTM7x7SdMmICWLVti165dCAwMxMWLF6Grq4vq1atjyJAh6NOnT+ntJBFRMYlkOTtMEhERERFRhcU+70REREREKoLJOxERERGRimDyTkRERESkIpi8ExERERGpCCbvREREREQqgsk7EREREZGKYPJORERERKQimLwTEREREakIJu9ERERERCqCyTsRERERkYr4PzMiKGT2ix4xAAAAAElFTkSuQmCC\n",
            "text/plain": [
              "\u003cFigure size 864x432 with 1 Axes\u003e"
            ]
          },
          "metadata": {
            "tags": []
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "#@title Options per second depending on the batch size\n",
        "\n",
        "batch_of_options = [1, 10, 100, 1000, 2000, 5000]  #@param\n",
        "gpu_times = []\n",
        "cpu_times = []\n",
        "\n",
        "for options in batch_of_options:\n",
        "    \n",
        "  with tf.device(\"/gpu:0\"):\n",
        "        \n",
        "    # Generate volatilities, rates, strikes\n",
        "    volatility, risk_free_rate, strike = option_param(options, dtype)\n",
        "    \n",
        "    # Warmup\n",
        "    estimate = american_option(\n",
        "        time_delta=time_delta,\n",
        "        expiry=expiry,\n",
        "        number_grid_points=number_grid_points,\n",
        "        volatility=volatility,\n",
        "        risk_free_rate=risk_free_rate,\n",
        "        strike=strike,\n",
        "        dtype=dtype)\n",
        "    \n",
        "    # Timed run\n",
        "    t = time.time()\n",
        "    estimate = american_option(\n",
        "        time_delta=time_delta,\n",
        "        expiry=expiry,\n",
        "        number_grid_points=number_grid_points,\n",
        "        volatility=volatility,\n",
        "        risk_free_rate=risk_free_rate,\n",
        "        strike=strike,\n",
        "        dtype=dtype)\n",
        "    time_gpu = time.time() - t\n",
        "\n",
        "  gpu_times.append(options / time_gpu)\n",
        "\n",
        "for options in batch_of_options:\n",
        "\n",
        "  with tf.device(\"/cpu:0\"):\n",
        "        \n",
        "    # Generate volatilities, rates, strikes\n",
        "    volatility, risk_free_rate, strike = option_param(options, dtype)\n",
        "    \n",
        "    # Warmup\n",
        "    estimate = american_option(\n",
        "        time_delta=time_delta,\n",
        "        expiry=expiry,\n",
        "        number_grid_points=number_grid_points,\n",
        "        volatility=volatility,\n",
        "        risk_free_rate=risk_free_rate,\n",
        "        strike=strike,\n",
        "        dtype=dtype)\n",
        "    \n",
        "    # Timed run\n",
        "    t = time.time()\n",
        "    estimate = american_option(\n",
        "        time_delta=time_delta,\n",
        "        expiry=expiry,\n",
        "        number_grid_points=number_grid_points,\n",
        "        volatility=volatility,\n",
        "        risk_free_rate=risk_free_rate,\n",
        "        strike=strike,\n",
        "        dtype=dtype)\n",
        "    time_cpu = time.time() - t\n",
        "    \n",
        "  cpu_times.append(options / time_cpu)\n",
        "\n",
        "# Prepare data for plotting\n",
        "plt.figure(figsize=(12, 6))\n",
        "batches = batch_of_options * 2\n",
        "num_batches = len(batch_of_options)\n",
        "method = [\"GPU\"] * num_batches +  [\"CPU\"] * num_batches\n",
        "times = gpu_times + cpu_times\n",
        "data = {\"Batch Size\": batches,\n",
        "        \"Hardware\": method,\n",
        "        \"Options/Sec\": times}\n",
        "gpu_cpu_times = pd.DataFrame(data = data)\n",
        "sns.set(style=\"darkgrid\", palette=\"Paired\")\n",
        "sns.set_context(\"notebook\", font_scale=1.25, rc={\"lines.linewidth\": 2.5})\n",
        "pt = sns.barplot(x=\"Batch Size\", y=\"Options/Sec\",hue=\"Hardware\", data=gpu_cpu_times)\n",
        "pt.axes.set_title(\"Batched Options Priced per Second (GPU vs CPU)\",fontsize=25)\n",
        "xlabel = pt.axes.get_xlabel()\n",
        "ylabel = pt.axes.get_ylabel()\n",
        "pt.axes.set_xlabel(xlabel, fontsize=20)\n",
        "pt.axes.set_ylabel(ylabel, fontsize=20)\n",
        "plt.show()"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "collapsed_sections": [
        "OnijmIHSD5_a"
      ],
      "name": "American_Option_Black_Scholes.ipynb",
      "provenance": [],
      "toc_visible": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}
